v3

package
v0.0.0-...-4370ff1 Latest Latest
Warning

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

 Go to latest Published: Mar 28, 2022 License: Apache-2.0 Imports: 35 Imported by: 5,856

Documentation

Overview

+k8s:deepcopy-gen=package +groupName=management.cattle.io

Index

Constants

View Source 
const (
	BackupConditionCreated   condition.Cond = "Created"
	BackupConditionCompleted condition.Cond = "Completed"
)
View Source 
const (
	ClusterScanConditionCreated      condition.Cond = typescond.Created
	ClusterScanConditionRunCompleted condition.Cond = typescond.RunCompleted
	ClusterScanConditionCompleted    condition.Cond = typescond.Completed
	ClusterScanConditionFailed       condition.Cond = typescond.Failed
	ClusterScanConditionAlerted      condition.Cond = typescond.Alerted

	ClusterScanTypeCis         = "cis"
	DefaultNamespaceForCis     = "security-scan"
	DefaultSonobuoyPodName     = "security-scan-runner"
	ConfigMapNameForUserConfig = "security-scan-cfg"

	SonobuoyCompletionAnnotation = "field.cattle.io/sonobuoyDone"
	CisHelmChartOwner            = "field.cattle.io/clusterScanOwner"

	ClusterScanRunTypeManual    ClusterScanRunType = "manual"
	ClusterScanRunTypeScheduled ClusterScanRunType = "scheduled"

	CisScanProfileTypePermissive CisScanProfileType = "permissive"
	CisScanProfileTypeHardened   CisScanProfileType = "hardened"

	DefaultScanOutputFileName string = "output.json"
)
View Source 
const (
	ClusterActionGenerateKubeconfig    = "generateKubeconfig"
	ClusterActionImportYaml            = "importYaml"
	ClusterActionExportYaml            = "exportYaml"
	ClusterActionViewMonitoring        = "viewMonitoring"
	ClusterActionEditMonitoring        = "editMonitoring"
	ClusterActionEnableMonitoring      = "enableMonitoring"
	ClusterActionDisableMonitoring     = "disableMonitoring"
	ClusterActionBackupEtcd            = "backupEtcd"
	ClusterActionRestoreFromEtcdBackup = "restoreFromEtcdBackup"
	ClusterActionRotateCertificates    = "rotateCertificates"
	ClusterActionRunSecurityScan       = "runSecurityScan"
	ClusterActionSaveAsTemplate        = "saveAsTemplate"

	// ClusterConditionReady Cluster ready to serve API (healthy when true, unhealthy when false)
	ClusterConditionReady          condition.Cond = "Ready"
	ClusterConditionPending        condition.Cond = "Pending"
	ClusterConditionCertsGenerated condition.Cond = "CertsGenerated"
	ClusterConditionEtcd           condition.Cond = "etcd"
	ClusterConditionProvisioned    condition.Cond = "Provisioned"
	ClusterConditionUpdated        condition.Cond = "Updated"
	ClusterConditionUpgraded       condition.Cond = "Upgraded"
	ClusterConditionWaiting        condition.Cond = "Waiting"
	ClusterConditionRemoved        condition.Cond = "Removed"
	// ClusterConditionNoDiskPressure true when all cluster nodes have sufficient disk
	ClusterConditionNoDiskPressure condition.Cond = "NoDiskPressure"
	// ClusterConditionNoMemoryPressure true when all cluster nodes have sufficient memory
	ClusterConditionNoMemoryPressure condition.Cond = "NoMemoryPressure"
	// ClusterConditionconditionDefaultProjectCreated true when default project has been created
	ClusterConditionconditionDefaultProjectCreated condition.Cond = "DefaultProjectCreated"
	// ClusterConditionconditionSystemProjectCreated true when system project has been created
	ClusterConditionconditionSystemProjectCreated condition.Cond = "SystemProjectCreated"
	// ClusterConditionDefaultNamespaceAssigned true when cluster's default namespace has been initially assigned
	ClusterConditionDefaultNamespaceAssigned condition.Cond = "DefaultNamespaceAssigned"
	// ClusterConditionSystemNamespacesAssigned true when cluster's system namespaces has been initially assigned to
	// a system project
	ClusterConditionSystemNamespacesAssigned   condition.Cond = "SystemNamespacesAssigned"
	ClusterConditionAddonDeploy                condition.Cond = "AddonDeploy"
	ClusterConditionSystemAccountCreated       condition.Cond = "SystemAccountCreated"
	ClusterConditionAgentDeployed              condition.Cond = "AgentDeployed"
	ClusterConditionGlobalAdminsSynced         condition.Cond = "GlobalAdminsSynced"
	ClusterConditionInitialRolesPopulated      condition.Cond = "InitialRolesPopulated"
	ClusterConditionServiceAccountMigrated     condition.Cond = "ServiceAccountMigrated"
	ClusterConditionPrometheusOperatorDeployed condition.Cond = "PrometheusOperatorDeployed"
	ClusterConditionMonitoringEnabled          condition.Cond = "MonitoringEnabled"
	ClusterConditionAlertingEnabled            condition.Cond = "AlertingEnabled"
	ClusterConditionSecretsMigrated            condition.Cond = "SecretsMigrated"

	ClusterDriverImported = "imported"
	ClusterDriverLocal    = "local"
	ClusterDriverRKE      = "rancherKubernetesEngine"
	ClusterDriverK3s      = "k3s"
	ClusterDriverK3os     = "k3os"
)
View Source 
const (
	MonitoringConditionGrafanaDeployed           condition.Cond = "GrafanaDeployed"
	MonitoringConditionPrometheusDeployed        condition.Cond = "PrometheusDeployed"
	MonitoringConditionAlertmaanagerDeployed     condition.Cond = "AlertmanagerDeployed"
	MonitoringConditionNodeExporterDeployed      condition.Cond = "NodeExporterDeployed"
	MonitoringConditionKubeStateExporterDeployed condition.Cond = "KubeStateExporterDeployed"
	MonitoringConditionMetricExpressionDeployed  condition.Cond = "MetricExpressionDeployed"
)
View Source 
const (
	GroupName = "management.cattle.io"
	Version   = "v3"
)
View Source 
const ClusterTemplateRevisionConditionSecretsMigrated condition.Cond = "SecretsMigrated"
View Source 
const UserConditionInitialRolesPopulated condition.Cond = "InitialRolesPopulated"

Variables

View Source 
var (
	NamespaceBackedResource                  condition.Cond = "BackingNamespaceCreated"
	CreatorMadeOwner                         condition.Cond = "CreatorMadeOwner"
	DefaultNetworkPolicyCreated              condition.Cond = "DefaultNetworkPolicyCreated"
	ProjectConditionInitialRolesPopulated    condition.Cond = "InitialRolesPopulated"
	ProjectConditionMonitoringEnabled        condition.Cond = "MonitoringEnabled"
	ProjectConditionMetricExpressionDeployed condition.Cond = "MetricExpressionDeployed"
)
View Source 
var (
	CatalogConditionRefreshed       condition.Cond = "Refreshed"
	CatalogConditionUpgraded        condition.Cond = "Upgraded"
	CatalogConditionDiskCached      condition.Cond = "DiskCached"
	CatalogConditionProcessed       condition.Cond = "Processed"
	CatalogConditionSecretsMigrated condition.Cond = "SecretsMigrated"
)
View Source 
var (
	KontainerDriverConditionDownloaded condition.Cond = "Downloaded"
	KontainerDriverConditionInstalled  condition.Cond = "Installed"
	KontainerDriverConditionActive     condition.Cond = "Active"
	KontainerDriverConditionInactive   condition.Cond = "Inactive"
)
View Source 
var (
	LoggingConditionProvisioned condition.Cond = "Provisioned"
	LoggingConditionUpdated     condition.Cond = "Updated"
)
View Source 
var (
	NodeConditionInitialized condition.Cond = "Initialized"
	NodeConditionProvisioned condition.Cond = "Provisioned"
	NodeConditionUpdated     condition.Cond = "Updated"
	NodeConditionRegistered  condition.Cond = "Registered"
	NodeConditionRemoved     condition.Cond = "Removed"
	NodeConditionConfigSaved condition.Cond = "Saved"
	NodeConditionReady       condition.Cond = "Ready"
	NodeConditionDrained     condition.Cond = "Drained"
	NodeConditionUpgraded    condition.Cond = "Upgraded"
)
View Source 
var (
	NodeDriverConditionDownloaded condition.Cond = "Downloaded"
	NodeDriverConditionInstalled  condition.Cond = "Installed"
	NodeDriverConditionActive     condition.Cond = "Active"
	NodeDriverConditionInactive   condition.Cond = "Inactive"
)
View Source 
var (
	MultiClusterAppConditionInstalled condition.Cond = "Installed"
	MultiClusterAppConditionDeployed  condition.Cond = "Deployed"
)
View Source 
var (
	AuthConfigGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "AuthConfig",
	}
	AuthConfigResource = metav1.APIResource{
		Name:         "authconfigs",
		SingularName: "authconfig",
		Namespaced:   false,
		Kind:         AuthConfigGroupVersionKind.Kind,
	}

	AuthConfigGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "authconfigs",
	}
)
View Source 
var (
	CatalogGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Catalog",
	}
	CatalogResource = metav1.APIResource{
		Name:         "catalogs",
		SingularName: "catalog",
		Namespaced:   false,
		Kind:         CatalogGroupVersionKind.Kind,
	}

	CatalogGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "catalogs",
	}
)
View Source 
var (
	CatalogTemplateGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "CatalogTemplate",
	}
	CatalogTemplateResource = metav1.APIResource{
		Name:         "catalogtemplates",
		SingularName: "catalogtemplate",
		Namespaced:   true,

		Kind: CatalogTemplateGroupVersionKind.Kind,
	}

	CatalogTemplateGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "catalogtemplates",
	}
)
View Source 
var (
	CatalogTemplateVersionGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "CatalogTemplateVersion",
	}
	CatalogTemplateVersionResource = metav1.APIResource{
		Name:         "catalogtemplateversions",
		SingularName: "catalogtemplateversion",
		Namespaced:   true,

		Kind: CatalogTemplateVersionGroupVersionKind.Kind,
	}

	CatalogTemplateVersionGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "catalogtemplateversions",
	}
)
View Source 
var (
	CisBenchmarkVersionGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "CisBenchmarkVersion",
	}
	CisBenchmarkVersionResource = metav1.APIResource{
		Name:         "cisbenchmarkversions",
		SingularName: "cisbenchmarkversion",
		Namespaced:   true,

		Kind: CisBenchmarkVersionGroupVersionKind.Kind,
	}

	CisBenchmarkVersionGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "cisbenchmarkversions",
	}
)
View Source 
var (
	CisConfigGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "CisConfig",
	}
	CisConfigResource = metav1.APIResource{
		Name:         "cisconfigs",
		SingularName: "cisconfig",
		Namespaced:   true,

		Kind: CisConfigGroupVersionKind.Kind,
	}

	CisConfigGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "cisconfigs",
	}
)
View Source 
var (
	CloudCredentialGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "CloudCredential",
	}
	CloudCredentialResource = metav1.APIResource{
		Name:         "cloudcredentials",
		SingularName: "cloudcredential",
		Namespaced:   true,

		Kind: CloudCredentialGroupVersionKind.Kind,
	}

	CloudCredentialGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "cloudcredentials",
	}
)
View Source 
var (
	ClusterAlertGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterAlert",
	}
	ClusterAlertResource = metav1.APIResource{
		Name:         "clusteralerts",
		SingularName: "clusteralert",
		Namespaced:   true,

		Kind: ClusterAlertGroupVersionKind.Kind,
	}

	ClusterAlertGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusteralerts",
	}
)
View Source 
var (
	ClusterAlertGroupGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterAlertGroup",
	}
	ClusterAlertGroupResource = metav1.APIResource{
		Name:         "clusteralertgroups",
		SingularName: "clusteralertgroup",
		Namespaced:   true,

		Kind: ClusterAlertGroupGroupVersionKind.Kind,
	}

	ClusterAlertGroupGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusteralertgroups",
	}
)
View Source 
var (
	ClusterAlertRuleGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterAlertRule",
	}
	ClusterAlertRuleResource = metav1.APIResource{
		Name:         "clusteralertrules",
		SingularName: "clusteralertrule",
		Namespaced:   true,

		Kind: ClusterAlertRuleGroupVersionKind.Kind,
	}

	ClusterAlertRuleGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusteralertrules",
	}
)
View Source 
var (
	ClusterCatalogGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterCatalog",
	}
	ClusterCatalogResource = metav1.APIResource{
		Name:         "clustercatalogs",
		SingularName: "clustercatalog",
		Namespaced:   true,

		Kind: ClusterCatalogGroupVersionKind.Kind,
	}

	ClusterCatalogGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clustercatalogs",
	}
)
View Source 
var (
	ClusterGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Cluster",
	}
	ClusterResource = metav1.APIResource{
		Name:         "clusters",
		SingularName: "cluster",
		Namespaced:   false,
		Kind:         ClusterGroupVersionKind.Kind,
	}

	ClusterGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusters",
	}
)
View Source 
var (
	ClusterLoggingGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterLogging",
	}
	ClusterLoggingResource = metav1.APIResource{
		Name:         "clusterloggings",
		SingularName: "clusterlogging",
		Namespaced:   true,

		Kind: ClusterLoggingGroupVersionKind.Kind,
	}

	ClusterLoggingGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusterloggings",
	}
)
View Source 
var (
	ClusterMonitorGraphGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterMonitorGraph",
	}
	ClusterMonitorGraphResource = metav1.APIResource{
		Name:         "clustermonitorgraphs",
		SingularName: "clustermonitorgraph",
		Namespaced:   true,

		Kind: ClusterMonitorGraphGroupVersionKind.Kind,
	}

	ClusterMonitorGraphGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clustermonitorgraphs",
	}
)
View Source 
var (
	ClusterRegistrationTokenGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterRegistrationToken",
	}
	ClusterRegistrationTokenResource = metav1.APIResource{
		Name:         "clusterregistrationtokens",
		SingularName: "clusterregistrationtoken",
		Namespaced:   true,

		Kind: ClusterRegistrationTokenGroupVersionKind.Kind,
	}

	ClusterRegistrationTokenGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusterregistrationtokens",
	}
)
View Source 
var (
	ClusterRoleTemplateBindingGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterRoleTemplateBinding",
	}
	ClusterRoleTemplateBindingResource = metav1.APIResource{
		Name:         "clusterroletemplatebindings",
		SingularName: "clusterroletemplatebinding",
		Namespaced:   true,

		Kind: ClusterRoleTemplateBindingGroupVersionKind.Kind,
	}

	ClusterRoleTemplateBindingGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusterroletemplatebindings",
	}
)
View Source 
var (
	ClusterScanGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterScan",
	}
	ClusterScanResource = metav1.APIResource{
		Name:         "clusterscans",
		SingularName: "clusterscan",
		Namespaced:   true,

		Kind: ClusterScanGroupVersionKind.Kind,
	}

	ClusterScanGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clusterscans",
	}
)
View Source 
var (
	ClusterTemplateGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterTemplate",
	}
	ClusterTemplateResource = metav1.APIResource{
		Name:         "clustertemplates",
		SingularName: "clustertemplate",
		Namespaced:   true,

		Kind: ClusterTemplateGroupVersionKind.Kind,
	}

	ClusterTemplateGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clustertemplates",
	}
)
View Source 
var (
	ClusterTemplateRevisionGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ClusterTemplateRevision",
	}
	ClusterTemplateRevisionResource = metav1.APIResource{
		Name:         "clustertemplaterevisions",
		SingularName: "clustertemplaterevision",
		Namespaced:   true,

		Kind: ClusterTemplateRevisionGroupVersionKind.Kind,
	}

	ClusterTemplateRevisionGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "clustertemplaterevisions",
	}
)
View Source 
var (
	ComposeConfigGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ComposeConfig",
	}
	ComposeConfigResource = metav1.APIResource{
		Name:         "composeconfigs",
		SingularName: "composeconfig",
		Namespaced:   false,
		Kind:         ComposeConfigGroupVersionKind.Kind,
	}

	ComposeConfigGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "composeconfigs",
	}
)
View Source 
var (
	DynamicSchemaGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "DynamicSchema",
	}
	DynamicSchemaResource = metav1.APIResource{
		Name:         "dynamicschemas",
		SingularName: "dynamicschema",
		Namespaced:   false,
		Kind:         DynamicSchemaGroupVersionKind.Kind,
	}

	DynamicSchemaGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "dynamicschemas",
	}
)
View Source 
var (
	EtcdBackupGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "EtcdBackup",
	}
	EtcdBackupResource = metav1.APIResource{
		Name:         "etcdbackups",
		SingularName: "etcdbackup",
		Namespaced:   true,

		Kind: EtcdBackupGroupVersionKind.Kind,
	}

	EtcdBackupGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "etcdbackups",
	}
)
View Source 
var (
	FeatureGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Feature",
	}
	FeatureResource = metav1.APIResource{
		Name:         "features",
		SingularName: "feature",
		Namespaced:   false,
		Kind:         FeatureGroupVersionKind.Kind,
	}

	FeatureGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "features",
	}
)
View Source 
var (
	GlobalDNSGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "GlobalDNS",
	}
	GlobalDNSResource = metav1.APIResource{
		Name:         "globaldnses",
		SingularName: "globaldns",
		Namespaced:   true,

		Kind: GlobalDNSGroupVersionKind.Kind,
	}

	GlobalDNSGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "globaldnses",
	}
)
View Source 
var (
	GlobalDNSProviderGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "GlobalDNSProvider",
	}
	GlobalDNSProviderResource = metav1.APIResource{
		Name:         "globaldnsproviders",
		SingularName: "globaldnsprovider",
		Namespaced:   true,

		Kind: GlobalDNSProviderGroupVersionKind.Kind,
	}

	GlobalDNSProviderGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "globaldnsproviders",
	}
)
View Source 
var (
	GlobalRoleBindingGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "GlobalRoleBinding",
	}
	GlobalRoleBindingResource = metav1.APIResource{
		Name:         "globalrolebindings",
		SingularName: "globalrolebinding",
		Namespaced:   false,
		Kind:         GlobalRoleBindingGroupVersionKind.Kind,
	}

	GlobalRoleBindingGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "globalrolebindings",
	}
)
View Source 
var (
	GlobalRoleGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "GlobalRole",
	}
	GlobalRoleResource = metav1.APIResource{
		Name:         "globalroles",
		SingularName: "globalrole",
		Namespaced:   false,
		Kind:         GlobalRoleGroupVersionKind.Kind,
	}

	GlobalRoleGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "globalroles",
	}
)
View Source 
var (
	GroupGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Group",
	}
	GroupResource = metav1.APIResource{
		Name:         "groups",
		SingularName: "group",
		Namespaced:   false,
		Kind:         GroupGroupVersionKind.Kind,
	}

	GroupGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "groups",
	}
)
View Source 
var (
	GroupMemberGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "GroupMember",
	}
	GroupMemberResource = metav1.APIResource{
		Name:         "groupmembers",
		SingularName: "groupmember",
		Namespaced:   false,
		Kind:         GroupMemberGroupVersionKind.Kind,
	}

	GroupMemberGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "groupmembers",
	}
)
View Source 
var (
	KontainerDriverGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "KontainerDriver",
	}
	KontainerDriverResource = metav1.APIResource{
		Name:         "kontainerdrivers",
		SingularName: "kontainerdriver",
		Namespaced:   false,
		Kind:         KontainerDriverGroupVersionKind.Kind,
	}

	KontainerDriverGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "kontainerdrivers",
	}
)
View Source 
var (
	LdapConfigGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "LdapConfig",
	}
	LdapConfigResource = metav1.APIResource{
		Name:         "ldapconfigs",
		SingularName: "ldapconfig",
		Namespaced:   false,
		Kind:         LdapConfigGroupVersionKind.Kind,
	}

	LdapConfigGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "ldapconfigs",
	}
)
View Source 
var (
	MonitorMetricGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "MonitorMetric",
	}
	MonitorMetricResource = metav1.APIResource{
		Name:         "monitormetrics",
		SingularName: "monitormetric",
		Namespaced:   true,

		Kind: MonitorMetricGroupVersionKind.Kind,
	}

	MonitorMetricGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "monitormetrics",
	}
)
View Source 
var (
	MultiClusterAppGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "MultiClusterApp",
	}
	MultiClusterAppResource = metav1.APIResource{
		Name:         "multiclusterapps",
		SingularName: "multiclusterapp",
		Namespaced:   true,

		Kind: MultiClusterAppGroupVersionKind.Kind,
	}

	MultiClusterAppGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "multiclusterapps",
	}
)
View Source 
var (
	MultiClusterAppRevisionGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "MultiClusterAppRevision",
	}
	MultiClusterAppRevisionResource = metav1.APIResource{
		Name:         "multiclusterapprevisions",
		SingularName: "multiclusterapprevision",
		Namespaced:   true,

		Kind: MultiClusterAppRevisionGroupVersionKind.Kind,
	}

	MultiClusterAppRevisionGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "multiclusterapprevisions",
	}
)
View Source 
var (
	NodeGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Node",
	}
	NodeResource = metav1.APIResource{
		Name:         "nodes",
		SingularName: "node",
		Namespaced:   true,

		Kind: NodeGroupVersionKind.Kind,
	}

	NodeGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "nodes",
	}
)
View Source 
var (
	NodeDriverGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "NodeDriver",
	}
	NodeDriverResource = metav1.APIResource{
		Name:         "nodedrivers",
		SingularName: "nodedriver",
		Namespaced:   false,
		Kind:         NodeDriverGroupVersionKind.Kind,
	}

	NodeDriverGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "nodedrivers",
	}
)
View Source 
var (
	NodePoolGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "NodePool",
	}
	NodePoolResource = metav1.APIResource{
		Name:         "nodepools",
		SingularName: "nodepool",
		Namespaced:   true,

		Kind: NodePoolGroupVersionKind.Kind,
	}

	NodePoolGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "nodepools",
	}
)
View Source 
var (
	NodeTemplateGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "NodeTemplate",
	}
	NodeTemplateResource = metav1.APIResource{
		Name:         "nodetemplates",
		SingularName: "nodetemplate",
		Namespaced:   true,

		Kind: NodeTemplateGroupVersionKind.Kind,
	}

	NodeTemplateGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "nodetemplates",
	}
)
View Source 
var (
	NotifierGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Notifier",
	}
	NotifierResource = metav1.APIResource{
		Name:         "notifiers",
		SingularName: "notifier",
		Namespaced:   true,

		Kind: NotifierGroupVersionKind.Kind,
	}

	NotifierGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "notifiers",
	}
)
View Source 
var (
	PodSecurityPolicyTemplateGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "PodSecurityPolicyTemplate",
	}
	PodSecurityPolicyTemplateResource = metav1.APIResource{
		Name:         "podsecuritypolicytemplates",
		SingularName: "podsecuritypolicytemplate",
		Namespaced:   false,
		Kind:         PodSecurityPolicyTemplateGroupVersionKind.Kind,
	}

	PodSecurityPolicyTemplateGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "podsecuritypolicytemplates",
	}
)
View Source 
var (
	PodSecurityPolicyTemplateProjectBindingGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "PodSecurityPolicyTemplateProjectBinding",
	}
	PodSecurityPolicyTemplateProjectBindingResource = metav1.APIResource{
		Name:         "podsecuritypolicytemplateprojectbindings",
		SingularName: "podsecuritypolicytemplateprojectbinding",
		Namespaced:   true,

		Kind: PodSecurityPolicyTemplateProjectBindingGroupVersionKind.Kind,
	}

	PodSecurityPolicyTemplateProjectBindingGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "podsecuritypolicytemplateprojectbindings",
	}
)
View Source 
var (
	PreferenceGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Preference",
	}
	PreferenceResource = metav1.APIResource{
		Name:         "preferences",
		SingularName: "preference",
		Namespaced:   true,

		Kind: PreferenceGroupVersionKind.Kind,
	}

	PreferenceGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "preferences",
	}
)
View Source 
var (
	PrincipalGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Principal",
	}
	PrincipalResource = metav1.APIResource{
		Name:         "principals",
		SingularName: "principal",
		Namespaced:   false,
		Kind:         PrincipalGroupVersionKind.Kind,
	}

	PrincipalGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "principals",
	}
)
View Source 
var (
	ProjectAlertGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectAlert",
	}
	ProjectAlertResource = metav1.APIResource{
		Name:         "projectalerts",
		SingularName: "projectalert",
		Namespaced:   true,

		Kind: ProjectAlertGroupVersionKind.Kind,
	}

	ProjectAlertGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectalerts",
	}
)
View Source 
var (
	ProjectAlertGroupGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectAlertGroup",
	}
	ProjectAlertGroupResource = metav1.APIResource{
		Name:         "projectalertgroups",
		SingularName: "projectalertgroup",
		Namespaced:   true,

		Kind: ProjectAlertGroupGroupVersionKind.Kind,
	}

	ProjectAlertGroupGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectalertgroups",
	}
)
View Source 
var (
	ProjectAlertRuleGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectAlertRule",
	}
	ProjectAlertRuleResource = metav1.APIResource{
		Name:         "projectalertrules",
		SingularName: "projectalertrule",
		Namespaced:   true,

		Kind: ProjectAlertRuleGroupVersionKind.Kind,
	}

	ProjectAlertRuleGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectalertrules",
	}
)
View Source 
var (
	ProjectCatalogGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectCatalog",
	}
	ProjectCatalogResource = metav1.APIResource{
		Name:         "projectcatalogs",
		SingularName: "projectcatalog",
		Namespaced:   true,

		Kind: ProjectCatalogGroupVersionKind.Kind,
	}

	ProjectCatalogGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectcatalogs",
	}
)
View Source 
var (
	ProjectGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Project",
	}
	ProjectResource = metav1.APIResource{
		Name:         "projects",
		SingularName: "project",
		Namespaced:   true,

		Kind: ProjectGroupVersionKind.Kind,
	}

	ProjectGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projects",
	}
)
View Source 
var (
	ProjectLoggingGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectLogging",
	}
	ProjectLoggingResource = metav1.APIResource{
		Name:         "projectloggings",
		SingularName: "projectlogging",
		Namespaced:   true,

		Kind: ProjectLoggingGroupVersionKind.Kind,
	}

	ProjectLoggingGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectloggings",
	}
)
View Source 
var (
	ProjectMonitorGraphGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectMonitorGraph",
	}
	ProjectMonitorGraphResource = metav1.APIResource{
		Name:         "projectmonitorgraphs",
		SingularName: "projectmonitorgraph",
		Namespaced:   true,

		Kind: ProjectMonitorGraphGroupVersionKind.Kind,
	}

	ProjectMonitorGraphGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectmonitorgraphs",
	}
)
View Source 
var (
	ProjectNetworkPolicyGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectNetworkPolicy",
	}
	ProjectNetworkPolicyResource = metav1.APIResource{
		Name:         "projectnetworkpolicies",
		SingularName: "projectnetworkpolicy",
		Namespaced:   true,

		Kind: ProjectNetworkPolicyGroupVersionKind.Kind,
	}

	ProjectNetworkPolicyGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectnetworkpolicies",
	}
)
View Source 
var (
	ProjectRoleTemplateBindingGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ProjectRoleTemplateBinding",
	}
	ProjectRoleTemplateBindingResource = metav1.APIResource{
		Name:         "projectroletemplatebindings",
		SingularName: "projectroletemplatebinding",
		Namespaced:   true,

		Kind: ProjectRoleTemplateBindingGroupVersionKind.Kind,
	}

	ProjectRoleTemplateBindingGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "projectroletemplatebindings",
	}
)
View Source 
var (
	RKEAddonGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "RKEAddon",
	}
	RKEAddonResource = metav1.APIResource{
		Name:         "rkeaddons",
		SingularName: "rkeaddon",
		Namespaced:   true,

		Kind: RKEAddonGroupVersionKind.Kind,
	}

	RKEAddonGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "rkeaddons",
	}
)
View Source 
var (
	RKEK8sServiceOptionGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "RKEK8sServiceOption",
	}
	RKEK8sServiceOptionResource = metav1.APIResource{
		Name:         "rkek8sserviceoptions",
		SingularName: "rkek8sserviceoption",
		Namespaced:   true,

		Kind: RKEK8sServiceOptionGroupVersionKind.Kind,
	}

	RKEK8sServiceOptionGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "rkek8sserviceoptions",
	}
)
View Source 
var (
	RKEK8sSystemImageGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "RKEK8sSystemImage",
	}
	RKEK8sSystemImageResource = metav1.APIResource{
		Name:         "rkek8ssystemimages",
		SingularName: "rkek8ssystemimage",
		Namespaced:   true,

		Kind: RKEK8sSystemImageGroupVersionKind.Kind,
	}

	RKEK8sSystemImageGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "rkek8ssystemimages",
	}
)
View Source 
var (
	RoleTemplateGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "RoleTemplate",
	}
	RoleTemplateResource = metav1.APIResource{
		Name:         "roletemplates",
		SingularName: "roletemplate",
		Namespaced:   false,
		Kind:         RoleTemplateGroupVersionKind.Kind,
	}

	RoleTemplateGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "roletemplates",
	}
)
View Source 
var (
	SamlTokenGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "SamlToken",
	}
	SamlTokenResource = metav1.APIResource{
		Name:         "samltokens",
		SingularName: "samltoken",
		Namespaced:   true,

		Kind: SamlTokenGroupVersionKind.Kind,
	}

	SamlTokenGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "samltokens",
	}
)
View Source 
var (
	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
	AddToScheme   = SchemeBuilder.AddToScheme
)
View Source 
var (
	SettingGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Setting",
	}
	SettingResource = metav1.APIResource{
		Name:         "settings",
		SingularName: "setting",
		Namespaced:   false,
		Kind:         SettingGroupVersionKind.Kind,
	}

	SettingGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "settings",
	}
)
View Source 
var (
	TemplateContentGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "TemplateContent",
	}
	TemplateContentResource = metav1.APIResource{
		Name:         "templatecontents",
		SingularName: "templatecontent",
		Namespaced:   false,
		Kind:         TemplateContentGroupVersionKind.Kind,
	}

	TemplateContentGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "templatecontents",
	}
)
View Source 
var (
	TemplateGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Template",
	}
	TemplateResource = metav1.APIResource{
		Name:         "templates",
		SingularName: "template",
		Namespaced:   false,
		Kind:         TemplateGroupVersionKind.Kind,
	}

	TemplateGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "templates",
	}
)
View Source 
var (
	TemplateVersionGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "TemplateVersion",
	}
	TemplateVersionResource = metav1.APIResource{
		Name:         "templateversions",
		SingularName: "templateversion",
		Namespaced:   false,
		Kind:         TemplateVersionGroupVersionKind.Kind,
	}

	TemplateVersionGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "templateversions",
	}
)
View Source 
var (
	TokenGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "Token",
	}
	TokenResource = metav1.APIResource{
		Name:         "tokens",
		SingularName: "token",
		Namespaced:   false,
		Kind:         TokenGroupVersionKind.Kind,
	}

	TokenGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "tokens",
	}
)
View Source 
var (
	UserAttributeGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "UserAttribute",
	}
	UserAttributeResource = metav1.APIResource{
		Name:         "userattributes",
		SingularName: "userattribute",
		Namespaced:   false,
		Kind:         UserAttributeGroupVersionKind.Kind,
	}

	UserAttributeGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "userattributes",
	}
)
View Source 
var (
	UserGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "User",
	}
	UserResource = metav1.APIResource{
		Name:         "users",
		SingularName: "user",
		Namespaced:   false,
		Kind:         UserGroupVersionKind.Kind,
	}

	UserGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "users",
	}
)
View Source 
var (
	ComposeConditionExecuted condition.Cond = "Executed"
)
View Source 
var (
	NodePoolConditionUpdated condition.Cond = "Updated"
)
View Source 
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: Version}

SchemeGroupVersion is group version used to register these objects

View Source 
var (
	ToolsSystemImages = struct {
		PipelineSystemImages projectv3.PipelineSystemImages
		AuthSystemImages     AuthSystemImages
	}{
		PipelineSystemImages: projectv3.PipelineSystemImages{
			Jenkins:       m("rancher/pipeline-jenkins-server:v0.1.4"),
			JenkinsJnlp:   m("jenkins/jnlp-slave:3.35-4"),
			AlpineGit:     m("rancher/pipeline-tools:v0.1.14"),
			PluginsDocker: m("plugins/docker:18.09"),
			Minio:         m("minio/minio:RELEASE.2020-07-13T18-09-56Z"),
			Registry:      m("registry:2"),
			RegistryProxy: m("rancher/pipeline-tools:v0.1.14"),
			KubeApply:     m("rancher/pipeline-tools:v0.1.14"),
		},
		AuthSystemImages: AuthSystemImages{
			KubeAPIAuth: m("rancher/kube-api-auth:v0.1.4"),
		},
	}
)

Functions

func Kind 

func Kind(kind string) schema.GroupKind

Kind takes an unqualified kind and returns a Group qualified GroupKind

func Resource 

func Resource(resource string) schema.GroupResource

Resource takes an unqualified resource and returns a Group qualified GroupResource

Types

type ADFSConfig 

type ADFSConfig struct {
	SamlConfig `json:",inline" mapstructure:",squash"`
}

func (*ADFSConfig) DeepCopy 

func (in *ADFSConfig) DeepCopy() *ADFSConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ADFSConfig.

func (*ADFSConfig) DeepCopyInto 

func (in *ADFSConfig) DeepCopyInto(out *ADFSConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ADFSConfig) DeepCopyObject 

func (in *ADFSConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type AWSCloudProvider 

type AWSCloudProvider struct {
	Global          GlobalAwsOpts              `json:"global" yaml:"global" ini:"Global,omitempty"`
	ServiceOverride map[string]ServiceOverride `json:"serviceOverride,omitempty" yaml:"service_override,omitempty" ini:"ServiceOverride,omitempty"`
}

AWSCloudProvider options

func (*AWSCloudProvider) DeepCopy 

func (in *AWSCloudProvider) DeepCopy() *AWSCloudProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AWSCloudProvider.

func (*AWSCloudProvider) DeepCopyInto 

func (in *AWSCloudProvider) DeepCopyInto(out *AWSCloudProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Action 

type Action struct {
	Input  string `json:"input,omitempty"`
	Output string `json:"output,omitempty"`
}

func (*Action) DeepCopy 

func (in *Action) DeepCopy() *Action

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Action.

func (*Action) DeepCopyInto 

func (in *Action) DeepCopyInto(out *Action)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ActiveDirectoryConfig 

type ActiveDirectoryConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	AuthConfig        `json:",inline" mapstructure:",squash"`

	Servers                      []string `json:"servers,omitempty"                     norman:"type=array[string],required"`
	Port                         int64    `json:"port,omitempty"                        norman:"default=389"`
	TLS                          bool     `json:"tls,omitempty"                         norman:"default=false"`
	StartTLS                     bool     `json:"starttls,omitempty"                    norman:"default=false"`
	Certificate                  string   `json:"certificate,omitempty"`
	DefaultLoginDomain           string   `json:"defaultLoginDomain,omitempty"`
	ServiceAccountUsername       string   `json:"serviceAccountUsername,omitempty"      norman:"required"`
	ServiceAccountPassword       string   `json:"serviceAccountPassword,omitempty"      norman:"type=password,required"`
	UserDisabledBitMask          int64    `json:"userDisabledBitMask,omitempty"         norman:"default=2"`
	UserSearchBase               string   `json:"userSearchBase,omitempty"              norman:"required"`
	UserSearchAttribute          string   `json:"userSearchAttribute,omitempty"         norman:"default=sAMAccountName|sn|givenName,required"`
	UserSearchFilter             string   `json:"userSearchFilter,omitempty"`
	UserLoginAttribute           string   `json:"userLoginAttribute,omitempty"          norman:"default=sAMAccountName,required"`
	UserObjectClass              string   `json:"userObjectClass,omitempty"             norman:"default=person,required"`
	UserNameAttribute            string   `json:"userNameAttribute,omitempty"           norman:"default=name,required"`
	UserEnabledAttribute         string   `json:"userEnabledAttribute,omitempty"        norman:"default=userAccountControl,required"`
	GroupSearchBase              string   `json:"groupSearchBase,omitempty"`
	GroupSearchAttribute         string   `json:"groupSearchAttribute,omitempty"        norman:"default=sAMAccountName,required"`
	GroupSearchFilter            string   `json:"groupSearchFilter,omitempty"`
	GroupObjectClass             string   `json:"groupObjectClass,omitempty"            norman:"default=group,required"`
	GroupNameAttribute           string   `json:"groupNameAttribute,omitempty"          norman:"default=name,required"`
	GroupDNAttribute             string   `json:"groupDNAttribute,omitempty"            norman:"default=distinguishedName,required"`
	GroupMemberUserAttribute     string   `json:"groupMemberUserAttribute,omitempty"    norman:"default=distinguishedName,required"`
	GroupMemberMappingAttribute  string   `json:"groupMemberMappingAttribute,omitempty" norman:"default=member,required"`
	ConnectionTimeout            int64    `json:"connectionTimeout,omitempty"           norman:"default=5000,notnullable,required"`
	NestedGroupMembershipEnabled *bool    `json:"nestedGroupMembershipEnabled,omitempty" norman:"default=false"`
}

func (*ActiveDirectoryConfig) DeepCopy 

func (in *ActiveDirectoryConfig) DeepCopy() *ActiveDirectoryConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ActiveDirectoryConfig.

func (*ActiveDirectoryConfig) DeepCopyInto 

func (in *ActiveDirectoryConfig) DeepCopyInto(out *ActiveDirectoryConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ActiveDirectoryConfig) DeepCopyObject 

func (in *ActiveDirectoryConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ActiveDirectoryTestAndApplyInput 

type ActiveDirectoryTestAndApplyInput struct {
	ActiveDirectoryConfig ActiveDirectoryConfig `json:"activeDirectoryConfig,omitempty"`
	Username              string                `json:"username"`
	Password              string                `json:"password"`
	Enabled               bool                  `json:"enabled,omitempty"`
}

func (*ActiveDirectoryTestAndApplyInput) DeepCopy 

func (in *ActiveDirectoryTestAndApplyInput) DeepCopy() *ActiveDirectoryTestAndApplyInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ActiveDirectoryTestAndApplyInput.

func (*ActiveDirectoryTestAndApplyInput) DeepCopyInto 

func (in *ActiveDirectoryTestAndApplyInput) DeepCopyInto(out *ActiveDirectoryTestAndApplyInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertCommonSpec 

type AlertCommonSpec struct {
	DisplayName           string      `json:"displayName,omitempty" norman:"required"`
	Description           string      `json:"description,omitempty"`
	Severity              string      `json:"severity,omitempty" norman:"required,options=info|critical|warning,default=critical"`
	Recipients            []Recipient `json:"recipients,omitempty" norman:"required"`
	InitialWaitSeconds    int         `json:"initialWaitSeconds,omitempty" norman:"required,default=180,min=0"`
	RepeatIntervalSeconds int         `json:"repeatIntervalSeconds,omitempty"  norman:"required,default=3600,min=0"`
}

func (*AlertCommonSpec) DeepCopy 

func (in *AlertCommonSpec) DeepCopy() *AlertCommonSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertCommonSpec.

func (*AlertCommonSpec) DeepCopyInto 

func (in *AlertCommonSpec) DeepCopyInto(out *AlertCommonSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertStatus 

type AlertStatus struct {
	AlertState string `json:"alertState,omitempty" norman:"options=active|inactive|alerting|muted,default=active"`
}

func (*AlertStatus) DeepCopy 

func (in *AlertStatus) DeepCopy() *AlertStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertStatus.

func (*AlertStatus) DeepCopyInto 

func (in *AlertStatus) DeepCopyInto(out *AlertStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlidnsProviderConfig 

type AlidnsProviderConfig struct {
	AccessKey         string            `json:"accessKey" norman:"notnullable,required,minLength=1"`
	SecretKey         string            `json:"secretKey" norman:"notnullable,required,minLength=1,type=password"`
	AdditionalOptions map[string]string `json:"additionalOptions,omitempty"`
}

func (*AlidnsProviderConfig) DeepCopy 

func (in *AlidnsProviderConfig) DeepCopy() *AlidnsProviderConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlidnsProviderConfig.

func (*AlidnsProviderConfig) DeepCopyInto 

func (in *AlidnsProviderConfig) DeepCopyInto(out *AlidnsProviderConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Answer 

type Answer struct {
	ProjectName string            `json:"projectName,omitempty" norman:"type=reference[project]"`
	ClusterName string            `json:"clusterName,omitempty" norman:"type=reference[cluster]"`
	Values      map[string]string `json:"values,omitempty" norman:"required"`
}

func (*Answer) DeepCopy 

func (in *Answer) DeepCopy() *Answer

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Answer.

func (*Answer) DeepCopyInto 

func (in *Answer) DeepCopyInto(out *Answer)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Answer) ObjClusterName 

func (a *Answer) ObjClusterName() string

type AuditLog 

type AuditLog struct {
	Enabled       bool            `yaml:"enabled" json:"enabled,omitempty"`
	Configuration *AuditLogConfig `yaml:"configuration" json:"configuration,omitempty"`
}

func (*AuditLog) DeepCopy 

func (in *AuditLog) DeepCopy() *AuditLog

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuditLog.

func (*AuditLog) DeepCopyInto 

func (in *AuditLog) DeepCopyInto(out *AuditLog)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AuditLogConfig 

type AuditLogConfig struct {
	MaxAge    int             `yaml:"max_age" json:"maxAge,omitempty"`
	MaxBackup int             `yaml:"max_backup" json:"maxBackup,omitempty"`
	MaxSize   int             `yaml:"max_size" json:"maxSize,omitempty"`
	Path      string          `yaml:"path" json:"path,omitempty"`
	Format    string          `yaml:"format" json:"format,omitempty"`
	Policy    *auditv1.Policy `yaml:"policy" json:"policy,omitempty" norman:"type=map[json]"`
}

func (*AuditLogConfig) DeepCopy 

func (in *AuditLogConfig) DeepCopy() *AuditLogConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuditLogConfig.

func (*AuditLogConfig) DeepCopyInto 

func (in *AuditLogConfig) DeepCopyInto(out *AuditLogConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AuthConfig 

type AuthConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Type                string   `json:"type" norman:"noupdate"`
	Enabled             bool     `json:"enabled,omitempty"`
	AccessMode          string   `json:"accessMode,omitempty" norman:"required,notnullable,type=enum,options=required|restricted|unrestricted"`
	AllowedPrincipalIDs []string `json:"allowedPrincipalIds,omitempty" norman:"type=array[reference[principal]]"`
}

func NewAuthConfig 

func NewAuthConfig(namespace, name string, obj AuthConfig) *AuthConfig

func (*AuthConfig) DeepCopy 

func (in *AuthConfig) DeepCopy() *AuthConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthConfig.

func (*AuthConfig) DeepCopyInto 

func (in *AuthConfig) DeepCopyInto(out *AuthConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*AuthConfig) DeepCopyObject 

func (in *AuthConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type AuthConfigChangeHandlerFunc 

type AuthConfigChangeHandlerFunc func(obj *AuthConfig) (runtime.Object, error)

type AuthConfigController 

type AuthConfigController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() AuthConfigLister
	AddHandler(ctx context.Context, name string, handler AuthConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync AuthConfigHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler AuthConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler AuthConfigHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type AuthConfigHandlerFunc 

type AuthConfigHandlerFunc func(key string, obj *AuthConfig) (runtime.Object, error)

func NewAuthConfigLifecycleAdapter 

func NewAuthConfigLifecycleAdapter(name string, clusterScoped bool, client AuthConfigInterface, l AuthConfigLifecycle) AuthConfigHandlerFunc

type AuthConfigInterface 

type AuthConfigInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*AuthConfig) (*AuthConfig, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*AuthConfig, error)
	Get(name string, opts metav1.GetOptions) (*AuthConfig, error)
	Update(*AuthConfig) (*AuthConfig, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*AuthConfigList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*AuthConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() AuthConfigController
	AddHandler(ctx context.Context, name string, sync AuthConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync AuthConfigHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle AuthConfigLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle AuthConfigLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AuthConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync AuthConfigHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AuthConfigLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle AuthConfigLifecycle)
}

type AuthConfigLifecycle 

type AuthConfigLifecycle interface {
	Create(obj *AuthConfig) (runtime.Object, error)
	Remove(obj *AuthConfig) (runtime.Object, error)
	Updated(obj *AuthConfig) (runtime.Object, error)
}

type AuthConfigList 

type AuthConfigList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []AuthConfig `json:"items"`
}

func (*AuthConfigList) DeepCopy 

func (in *AuthConfigList) DeepCopy() *AuthConfigList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthConfigList.

func (*AuthConfigList) DeepCopyInto 

func (in *AuthConfigList) DeepCopyInto(out *AuthConfigList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*AuthConfigList) DeepCopyObject 

func (in *AuthConfigList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type AuthConfigLister 

type AuthConfigLister interface {
	List(namespace string, selector labels.Selector) (ret []*AuthConfig, err error)
	Get(namespace, name string) (*AuthConfig, error)
}

type AuthConfigsGetter 

type AuthConfigsGetter interface {
	AuthConfigs(namespace string) AuthConfigInterface
}

type AuthSystemImages 

type AuthSystemImages struct {
	KubeAPIAuth string `json:"kubeAPIAuth,omitempty"`
}

func (*AuthSystemImages) DeepCopy 

func (in *AuthSystemImages) DeepCopy() *AuthSystemImages

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthSystemImages.

func (*AuthSystemImages) DeepCopyInto 

func (in *AuthSystemImages) DeepCopyInto(out *AuthSystemImages)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AuthWebhookConfig 

type AuthWebhookConfig struct {
	// ConfigFile is a multiline string that represent a custom webhook config file
	ConfigFile string `yaml:"config_file" json:"configFile,omitempty"`
	// CacheTimeout controls how long to cache authentication decisions
	CacheTimeout string `yaml:"cache_timeout" json:"cacheTimeout,omitempty"`
}

func (*AuthWebhookConfig) DeepCopy 

func (in *AuthWebhookConfig) DeepCopy() *AuthWebhookConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthWebhookConfig.

func (*AuthWebhookConfig) DeepCopyInto 

func (in *AuthWebhookConfig) DeepCopyInto(out *AuthWebhookConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AuthnConfig 

type AuthnConfig struct {
	// Authentication strategy that will be used in kubernetes cluster
	Strategy string `yaml:"strategy" json:"strategy,omitempty" norman:"default=x509"`
	// List of additional hostnames and IPs to include in the api server PKI cert
	SANs []string `yaml:"sans" json:"sans,omitempty"`
	// Webhook configuration options
	Webhook *AuthWebhookConfig `yaml:"webhook" json:"webhook,omitempty"`
}

func (*AuthnConfig) DeepCopy 

func (in *AuthnConfig) DeepCopy() *AuthnConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthnConfig.

func (*AuthnConfig) DeepCopyInto 

func (in *AuthnConfig) DeepCopyInto(out *AuthnConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AuthzConfig 

type AuthzConfig struct {
	// Authorization mode used by kubernetes
	Mode string `yaml:"mode" json:"mode,omitempty"`
	// Authorization mode options
	Options map[string]string `yaml:"options" json:"options,omitempty"`
}

func (*AuthzConfig) DeepCopy 

func (in *AuthzConfig) DeepCopy() *AuthzConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthzConfig.

func (*AuthzConfig) DeepCopyInto 

func (in *AuthzConfig) DeepCopyInto(out *AuthzConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AzureADConfig 

type AzureADConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	AuthConfig        `json:",inline" mapstructure:",squash"`

	Endpoint          string `json:"endpoint,omitempty" norman:"default=https://login.microsoftonline.com/,required,notnullable"`
	GraphEndpoint     string `json:"graphEndpoint,omitempty" norman:"required,notnullable"`
	TokenEndpoint     string `json:"tokenEndpoint,omitempty" norman:"required,notnullable"`
	AuthEndpoint      string `json:"authEndpoint,omitempty" norman:"required,notnullable"`
	TenantID          string `json:"tenantId,omitempty" norman:"required,notnullable"`
	ApplicationID     string `json:"applicationId,omitempty" norman:"required,notnullable"`
	ApplicationSecret string `json:"applicationSecret,omitempty" norman:"required,notnullable,type=password"`
	RancherURL        string `json:"rancherUrl,omitempty" norman:"required,notnullable"`
}

func (*AzureADConfig) DeepCopy 

func (in *AzureADConfig) DeepCopy() *AzureADConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureADConfig.

func (*AzureADConfig) DeepCopyInto 

func (in *AzureADConfig) DeepCopyInto(out *AzureADConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*AzureADConfig) DeepCopyObject 

func (in *AzureADConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type AzureADConfigApplyInput 

type AzureADConfigApplyInput struct {
	Config AzureADConfig `json:"config,omitempty"`
	Code   string        `json:"code,omitempty"`
}

func (*AzureADConfigApplyInput) DeepCopy 

func (in *AzureADConfigApplyInput) DeepCopy() *AzureADConfigApplyInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureADConfigApplyInput.

func (*AzureADConfigApplyInput) DeepCopyInto 

func (in *AzureADConfigApplyInput) DeepCopyInto(out *AzureADConfigApplyInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AzureADConfigTestOutput 

type AzureADConfigTestOutput struct {
	RedirectURL string `json:"redirectUrl"`
}

func (*AzureADConfigTestOutput) DeepCopy 

func (in *AzureADConfigTestOutput) DeepCopy() *AzureADConfigTestOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureADConfigTestOutput.

func (*AzureADConfigTestOutput) DeepCopyInto 

func (in *AzureADConfigTestOutput) DeepCopyInto(out *AzureADConfigTestOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AzureCloudProvider 

type AzureCloudProvider struct {
	// The cloud environment identifier. Takes values from https://github.com/Azure/go-autorest/blob/ec5f4903f77ed9927ac95b19ab8e44ada64c1356/autorest/azure/environments.go#L13
	Cloud string `json:"cloud" yaml:"cloud"`
	// The AAD Tenant ID for the Subscription that the cluster is deployed in
	TenantID string `json:"tenantId" yaml:"tenantId"`
	// The ID of the Azure Subscription that the cluster is deployed in
	SubscriptionID string `json:"subscriptionId" yaml:"subscriptionId"`
	// The name of the resource group that the cluster is deployed in
	ResourceGroup string `json:"resourceGroup" yaml:"resourceGroup"`
	// The location of the resource group that the cluster is deployed in
	Location string `json:"location" yaml:"location"`
	// The name of the VNet that the cluster is deployed in
	VnetName string `json:"vnetName" yaml:"vnetName"`
	// The name of the resource group that the Vnet is deployed in
	VnetResourceGroup string `json:"vnetResourceGroup" yaml:"vnetResourceGroup"`
	// The name of the subnet that the cluster is deployed in
	SubnetName string `json:"subnetName" yaml:"subnetName"`
	// The name of the security group attached to the cluster's subnet
	SecurityGroupName string `json:"securityGroupName" yaml:"securityGroupName"`
	// (Optional in 1.6) The name of the route table attached to the subnet that the cluster is deployed in
	RouteTableName string `json:"routeTableName" yaml:"routeTableName"`
	// (Optional) The name of the availability set that should be used as the load balancer backend
	// If this is set, the Azure cloudprovider will only add nodes from that availability set to the load
	// balancer backend pool. If this is not set, and multiple agent pools (availability sets) are used, then
	// the cloudprovider will try to add all nodes to a single backend pool which is forbidden.
	// In other words, if you use multiple agent pools (availability sets), you MUST set this field.
	PrimaryAvailabilitySetName string `json:"primaryAvailabilitySetName" yaml:"primaryAvailabilitySetName"`
	// The type of azure nodes. Candidate valudes are: vmss and standard.
	// If not set, it will be default to standard.
	VMType string `json:"vmType" yaml:"vmType"`
	// The name of the scale set that should be used as the load balancer backend.
	// If this is set, the Azure cloudprovider will only add nodes from that scale set to the load
	// balancer backend pool. If this is not set, and multiple agent pools (scale sets) are used, then
	// the cloudprovider will try to add all nodes to a single backend pool which is forbidden.
	// In other words, if you use multiple agent pools (scale sets), you MUST set this field.
	PrimaryScaleSetName string `json:"primaryScaleSetName" yaml:"primaryScaleSetName"`
	// The ClientID for an AAD application with RBAC access to talk to Azure RM APIs
	// This's used for service principal authentication: https://github.com/Azure/aks-engine/blob/master/docs/topics/service-principals.md
	AADClientID string `json:"aadClientId" yaml:"aadClientId"`
	// The ClientSecret for an AAD application with RBAC access to talk to Azure RM APIs
	// This's used for service principal authentication: https://github.com/Azure/aks-engine/blob/master/docs/topics/service-principals.md
	AADClientSecret string `json:"aadClientSecret" yaml:"aadClientSecret" norman:"type=password"`
	// The path of a client certificate for an AAD application with RBAC access to talk to Azure RM APIs
	// This's used for client certificate authentication: https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-protocols-oauth-service-to-service
	AADClientCertPath string `json:"aadClientCertPath" yaml:"aadClientCertPath"`
	// The password of the client certificate for an AAD application with RBAC access to talk to Azure RM APIs
	// This's used for client certificate authentication: https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-protocols-oauth-service-to-service
	AADClientCertPassword string `json:"aadClientCertPassword" yaml:"aadClientCertPassword" norman:"type=password"`
	// Enable exponential backoff to manage resource request retries
	CloudProviderBackoff bool `json:"cloudProviderBackoff" yaml:"cloudProviderBackoff"`
	// Backoff retry limit
	CloudProviderBackoffRetries int `json:"cloudProviderBackoffRetries" yaml:"cloudProviderBackoffRetries"`
	// Backoff exponent
	CloudProviderBackoffExponent int `json:"cloudProviderBackoffExponent" yaml:"cloudProviderBackoffExponent"`
	// Backoff duration
	CloudProviderBackoffDuration int `json:"cloudProviderBackoffDuration" yaml:"cloudProviderBackoffDuration"`
	// Backoff jitter
	CloudProviderBackoffJitter int `json:"cloudProviderBackoffJitter" yaml:"cloudProviderBackoffJitter"`
	// Enable rate limiting
	CloudProviderRateLimit bool `json:"cloudProviderRateLimit" yaml:"cloudProviderRateLimit"`
	// Rate limit QPS
	CloudProviderRateLimitQPS int `json:"cloudProviderRateLimitQPS" yaml:"cloudProviderRateLimitQPS"`
	// Rate limit Bucket Size
	CloudProviderRateLimitBucket int `json:"cloudProviderRateLimitBucket" yaml:"cloudProviderRateLimitBucket"`
	// Use instance metadata service where possible
	UseInstanceMetadata bool `json:"useInstanceMetadata" yaml:"useInstanceMetadata"`
	// Use managed service identity for the virtual machine to access Azure ARM APIs
	// This's used for managed identity authentication: https://docs.microsoft.com/en-us/azure/active-directory/managed-service-identity/overview
	// For user-assigned managed identity, need to set the below UserAssignedIdentityID
	UseManagedIdentityExtension bool `json:"useManagedIdentityExtension" yaml:"useManagedIdentityExtension"`
	// The Client ID of the user assigned MSI which is assigned to the underlying VMs
	// This's used for managed identity authentication: https://docs.microsoft.com/en-us/azure/active-directory/managed-service-identity/overview
	UserAssignedIdentityID string `json:"userAssignedIdentityID,omitempty" yaml:"userAssignedIdentityID,omitempty"`
	// Maximum allowed LoadBalancer Rule Count is the limit enforced by Azure Load balancer, default(0) to 148
	MaximumLoadBalancerRuleCount int `json:"maximumLoadBalancerRuleCount" yaml:"maximumLoadBalancerRuleCount"`
	// Sku of Load Balancer and Public IP: `basic` or `standard`, default(blank) to `basic`
	LoadBalancerSku string `json:"loadBalancerSku,omitempty" yaml:"loadBalancerSku,omitempty"`
	// Excludes master nodes (labeled with `node-role.kubernetes.io/master`) from the backend pool of Azure standard loadbalancer, default(nil) to `true`
	// If want adding the master nodes to ALB, this should be set to `false` and remove the `node-role.kubernetes.io/master` label from master nodes
	ExcludeMasterFromStandardLB *bool `json:"excludeMasterFromStandardLB,omitempty" yaml:"excludeMasterFromStandardLB,omitempty"`
}

AzureCloudProvider options

func (*AzureCloudProvider) DeepCopy 

func (in *AzureCloudProvider) DeepCopy() *AzureCloudProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureCloudProvider.

func (*AzureCloudProvider) DeepCopyInto 

func (in *AzureCloudProvider) DeepCopyInto(out *AzureCloudProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type BackupConfig 

type BackupConfig struct {
	// Enable or disable recurring backups in rancher
	Enabled *bool `yaml:"enabled" json:"enabled,omitempty" norman:"default=true"`
	// Backup interval in hours
	IntervalHours int `yaml:"interval_hours" json:"intervalHours,omitempty" norman:"default=12"`
	// Number of backups to keep
	Retention int `yaml:"retention" json:"retention,omitempty" norman:"default=6"`
	// s3 target
	S3BackupConfig *S3BackupConfig `yaml:",omitempty" json:"s3BackupConfig"`
	// replace special characters in snapshot names
	SafeTimestamp bool `yaml:"safe_timestamp" json:"safeTimestamp,omitempty"`
	// Backup execution timeout
	Timeout int `yaml:"timeout" json:"timeout,omitempty" norman:"default=300"`
}

func (*BackupConfig) DeepCopy 

func (in *BackupConfig) DeepCopy() *BackupConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackupConfig.

func (*BackupConfig) DeepCopyInto 

func (in *BackupConfig) DeepCopyInto(out *BackupConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type BaseService 

type BaseService struct {
	// Docker image of the service
	Image string `yaml:"image" json:"image,omitempty"`
	// Extra arguments that are added to the services
	ExtraArgs map[string]string `yaml:"extra_args" json:"extraArgs,omitempty"`
	// Extra binds added to the nodes
	ExtraBinds []string `yaml:"extra_binds" json:"extraBinds,omitempty"`
	// this is to provide extra env variable to the docker container running kubernetes service
	ExtraEnv []string `yaml:"extra_env" json:"extraEnv,omitempty"`

	// Windows nodes only of the same as the above
	// Extra arguments that are added to the services
	WindowsExtraArgs map[string]string `yaml:"win_extra_args" json:"winExtraArgs,omitempty"`
	// Extra binds added to the nodes
	WindowsExtraBinds []string `yaml:"win_extra_binds" json:"winExtraBinds,omitempty"`
	// this is to provide extra env variable to the docker container running kubernetes service
	WindowsExtraEnv []string `yaml:"win_extra_env" json:"winExtraEnv,omitempty"`
}

func (*BaseService) DeepCopy 

func (in *BaseService) DeepCopy() *BaseService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BaseService.

func (*BaseService) DeepCopyInto 

func (in *BaseService) DeepCopyInto(out *BaseService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type BastionHost 

type BastionHost struct {
	// Address of Bastion Host
	Address string `yaml:"address" json:"address,omitempty"`
	// SSH Port of Bastion Host
	Port string `yaml:"port" json:"port,omitempty"`
	// ssh User to Bastion Host
	User string `yaml:"user" json:"user,omitempty"`
	// SSH Agent Auth enable
	SSHAgentAuth bool `yaml:"ssh_agent_auth,omitempty" json:"sshAgentAuth,omitempty"`
	// SSH Private Key
	SSHKey string `yaml:"ssh_key" json:"sshKey,omitempty" norman:"type=password"`
	// SSH Private Key Path
	SSHKeyPath string `yaml:"ssh_key_path" json:"sshKeyPath,omitempty"`
	// SSH Certificate
	SSHCert string `yaml:"ssh_cert" json:"sshCert,omitempty"`
	// SSH Certificate Path
	SSHCertPath string `yaml:"ssh_cert_path" json:"sshCertPath,omitempty"`
}

func (*BastionHost) DeepCopy 

func (in *BastionHost) DeepCopy() *BastionHost

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BastionHost.

func (*BastionHost) DeepCopyInto 

func (in *BastionHost) DeepCopyInto(out *BastionHost)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type BlockStorageOpenstackOpts 

type BlockStorageOpenstackOpts struct {
	BSVersion       string `json:"bs-version" yaml:"bs-version" ini:"bs-version,omitempty"`                      // overrides autodetection. v1 or v2. Defaults to auto
	TrustDevicePath bool   `json:"trust-device-path" yaml:"trust-device-path" ini:"trust-device-path,omitempty"` // See Issue #33128
	IgnoreVolumeAZ  bool   `json:"ignore-volume-az" yaml:"ignore-volume-az" ini:"ignore-volume-az,omitempty"`
}

func (*BlockStorageOpenstackOpts) DeepCopy 

func (in *BlockStorageOpenstackOpts) DeepCopy() *BlockStorageOpenstackOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BlockStorageOpenstackOpts.

func (*BlockStorageOpenstackOpts) DeepCopyInto 

func (in *BlockStorageOpenstackOpts) DeepCopyInto(out *BlockStorageOpenstackOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CalicoNetworkProvider 

type CalicoNetworkProvider struct {
	// Cloud provider type used with calico
	CloudProvider string `json:"cloudProvider"`
}

func (*CalicoNetworkProvider) DeepCopy 

func (in *CalicoNetworkProvider) DeepCopy() *CalicoNetworkProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CalicoNetworkProvider.

func (*CalicoNetworkProvider) DeepCopyInto 

func (in *CalicoNetworkProvider) DeepCopyInto(out *CalicoNetworkProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CanalNetworkProvider 

type CanalNetworkProvider struct {
	FlannelNetworkProvider `yaml:",inline" json:",inline"`
}

func (*CanalNetworkProvider) DeepCopy 

func (in *CanalNetworkProvider) DeepCopy() *CanalNetworkProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CanalNetworkProvider.

func (*CanalNetworkProvider) DeepCopyInto 

func (in *CanalNetworkProvider) DeepCopyInto(out *CanalNetworkProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Capabilities 

type Capabilities struct {
	LoadBalancerCapabilities LoadBalancerCapabilities `json:"loadBalancerCapabilities,omitempty"`
	IngressCapabilities      []IngressCapabilities    `json:"ingressCapabilities,omitempty"`
	NodePoolScalingSupported bool                     `json:"nodePoolScalingSupported,omitempty"`
	NodePortRange            string                   `json:"nodePortRange,omitempty"`
	TaintSupport             *bool                    `json:"taintSupport,omitempty"`
	PspEnabled               bool                     `json:"pspEnabled,omitempty"`
}

func (*Capabilities) DeepCopy 

func (in *Capabilities) DeepCopy() *Capabilities

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Capabilities.

func (*Capabilities) DeepCopyInto 

func (in *Capabilities) DeepCopyInto(out *Capabilities)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Catalog 

type Catalog struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec   CatalogSpec   `json:"spec"`
	Status CatalogStatus `json:"status"`
}

func NewCatalog 

func NewCatalog(namespace, name string, obj Catalog) *Catalog

func (*Catalog) DeepCopy 

func (in *Catalog) DeepCopy() *Catalog

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Catalog.

func (*Catalog) DeepCopyInto 

func (in *Catalog) DeepCopyInto(out *Catalog)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Catalog) DeepCopyObject 

func (in *Catalog) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CatalogChangeHandlerFunc 

type CatalogChangeHandlerFunc func(obj *Catalog) (runtime.Object, error)

type CatalogCondition 

type CatalogCondition struct {
	// Type of cluster condition.
	Type ClusterConditionType `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*CatalogCondition) DeepCopy 

func (in *CatalogCondition) DeepCopy() *CatalogCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogCondition.

func (*CatalogCondition) DeepCopyInto 

func (in *CatalogCondition) DeepCopyInto(out *CatalogCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CatalogController 

type CatalogController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() CatalogLister
	AddHandler(ctx context.Context, name string, handler CatalogHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CatalogHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CatalogHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler CatalogHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type CatalogHandlerFunc 

type CatalogHandlerFunc func(key string, obj *Catalog) (runtime.Object, error)

func NewCatalogLifecycleAdapter 

func NewCatalogLifecycleAdapter(name string, clusterScoped bool, client CatalogInterface, l CatalogLifecycle) CatalogHandlerFunc

type CatalogInterface 

type CatalogInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Catalog) (*Catalog, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Catalog, error)
	Get(name string, opts metav1.GetOptions) (*Catalog, error)
	Update(*Catalog) (*Catalog, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*CatalogList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*CatalogList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() CatalogController
	AddHandler(ctx context.Context, name string, sync CatalogHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CatalogHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle CatalogLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle CatalogLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CatalogHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync CatalogHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CatalogLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle CatalogLifecycle)
}

type CatalogLifecycle 

type CatalogLifecycle interface {
	Create(obj *Catalog) (runtime.Object, error)
	Remove(obj *Catalog) (runtime.Object, error)
	Updated(obj *Catalog) (runtime.Object, error)
}

type CatalogList 

type CatalogList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Catalog `json:"items"`
}

func (*CatalogList) DeepCopy 

func (in *CatalogList) DeepCopy() *CatalogList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogList.

func (*CatalogList) DeepCopyInto 

func (in *CatalogList) DeepCopyInto(out *CatalogList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CatalogList) DeepCopyObject 

func (in *CatalogList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CatalogLister 

type CatalogLister interface {
	List(namespace string, selector labels.Selector) (ret []*Catalog, err error)
	Get(namespace, name string) (*Catalog, error)
}

type CatalogRefresh 

type CatalogRefresh struct {
	Catalogs []string `json:"catalogs"`
}

func (*CatalogRefresh) DeepCopy 

func (in *CatalogRefresh) DeepCopy() *CatalogRefresh

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogRefresh.

func (*CatalogRefresh) DeepCopyInto 

func (in *CatalogRefresh) DeepCopyInto(out *CatalogRefresh)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CatalogSpec 

type CatalogSpec struct {
	Description string `json:"description"`
	URL         string `json:"url,omitempty" norman:"required"`
	Branch      string `json:"branch,omitempty"`
	CatalogKind string `json:"catalogKind,omitempty"`
	Username    string `json:"username,omitempty"`
	Password    string `json:"password,omitempty" norman:"type=password"`
	HelmVersion string `json:"helmVersion,omitempty" norman:"noupdate"`
}

func (*CatalogSpec) DeepCopy 

func (in *CatalogSpec) DeepCopy() *CatalogSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogSpec.

func (*CatalogSpec) DeepCopyInto 

func (in *CatalogSpec) DeepCopyInto(out *CatalogSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CatalogStatus 

type CatalogStatus struct {
	LastRefreshTimestamp string `json:"lastRefreshTimestamp,omitempty"`
	Commit               string `json:"commit,omitempty"`
	// helmVersionCommits records hash of each helm template version
	HelmVersionCommits map[string]VersionCommits `json:"helmVersionCommits,omitempty"`
	Conditions         []CatalogCondition        `json:"conditions,omitempty"`
	CredentialSecret   string                    `json:"credentialSecret,omitempty" norman:"nocreate,noupdate"`
}

func (*CatalogStatus) DeepCopy 

func (in *CatalogStatus) DeepCopy() *CatalogStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogStatus.

func (*CatalogStatus) DeepCopyInto 

func (in *CatalogStatus) DeepCopyInto(out *CatalogStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CatalogTemplate 

type CatalogTemplate struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Template
}

func NewCatalogTemplate 

func NewCatalogTemplate(namespace, name string, obj CatalogTemplate) *CatalogTemplate

func (*CatalogTemplate) DeepCopy 

func (in *CatalogTemplate) DeepCopy() *CatalogTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogTemplate.

func (*CatalogTemplate) DeepCopyInto 

func (in *CatalogTemplate) DeepCopyInto(out *CatalogTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CatalogTemplate) DeepCopyObject 

func (in *CatalogTemplate) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CatalogTemplateChangeHandlerFunc 

type CatalogTemplateChangeHandlerFunc func(obj *CatalogTemplate) (runtime.Object, error)

type CatalogTemplateController 

type CatalogTemplateController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() CatalogTemplateLister
	AddHandler(ctx context.Context, name string, handler CatalogTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CatalogTemplateHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CatalogTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler CatalogTemplateHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type CatalogTemplateHandlerFunc 

type CatalogTemplateHandlerFunc func(key string, obj *CatalogTemplate) (runtime.Object, error)

func NewCatalogTemplateLifecycleAdapter 

func NewCatalogTemplateLifecycleAdapter(name string, clusterScoped bool, client CatalogTemplateInterface, l CatalogTemplateLifecycle) CatalogTemplateHandlerFunc

type CatalogTemplateInterface 

type CatalogTemplateInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*CatalogTemplate) (*CatalogTemplate, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*CatalogTemplate, error)
	Get(name string, opts metav1.GetOptions) (*CatalogTemplate, error)
	Update(*CatalogTemplate) (*CatalogTemplate, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*CatalogTemplateList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*CatalogTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() CatalogTemplateController
	AddHandler(ctx context.Context, name string, sync CatalogTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CatalogTemplateHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle CatalogTemplateLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle CatalogTemplateLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CatalogTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync CatalogTemplateHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CatalogTemplateLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle CatalogTemplateLifecycle)
}

type CatalogTemplateLifecycle 

type CatalogTemplateLifecycle interface {
	Create(obj *CatalogTemplate) (runtime.Object, error)
	Remove(obj *CatalogTemplate) (runtime.Object, error)
	Updated(obj *CatalogTemplate) (runtime.Object, error)
}

type CatalogTemplateList 

type CatalogTemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []CatalogTemplate `json:"items"`
}

func (*CatalogTemplateList) DeepCopy 

func (in *CatalogTemplateList) DeepCopy() *CatalogTemplateList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogTemplateList.

func (*CatalogTemplateList) DeepCopyInto 

func (in *CatalogTemplateList) DeepCopyInto(out *CatalogTemplateList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CatalogTemplateList) DeepCopyObject 

func (in *CatalogTemplateList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CatalogTemplateLister 

type CatalogTemplateLister interface {
	List(namespace string, selector labels.Selector) (ret []*CatalogTemplate, err error)
	Get(namespace, name string) (*CatalogTemplate, error)
}

type CatalogTemplateVersion 

type CatalogTemplateVersion struct {
	types.Namespaced
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	TemplateVersion
}

func NewCatalogTemplateVersion 

func NewCatalogTemplateVersion(namespace, name string, obj CatalogTemplateVersion) *CatalogTemplateVersion

func (*CatalogTemplateVersion) DeepCopy 

func (in *CatalogTemplateVersion) DeepCopy() *CatalogTemplateVersion

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogTemplateVersion.

func (*CatalogTemplateVersion) DeepCopyInto 

func (in *CatalogTemplateVersion) DeepCopyInto(out *CatalogTemplateVersion)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CatalogTemplateVersion) DeepCopyObject 

func (in *CatalogTemplateVersion) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CatalogTemplateVersionChangeHandlerFunc 

type CatalogTemplateVersionChangeHandlerFunc func(obj *CatalogTemplateVersion) (runtime.Object, error)

type CatalogTemplateVersionController 

type CatalogTemplateVersionController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() CatalogTemplateVersionLister
	AddHandler(ctx context.Context, name string, handler CatalogTemplateVersionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CatalogTemplateVersionHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CatalogTemplateVersionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler CatalogTemplateVersionHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type CatalogTemplateVersionHandlerFunc 

type CatalogTemplateVersionHandlerFunc func(key string, obj *CatalogTemplateVersion) (runtime.Object, error)

func NewCatalogTemplateVersionLifecycleAdapter 

func NewCatalogTemplateVersionLifecycleAdapter(name string, clusterScoped bool, client CatalogTemplateVersionInterface, l CatalogTemplateVersionLifecycle) CatalogTemplateVersionHandlerFunc

type CatalogTemplateVersionInterface 

type CatalogTemplateVersionInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*CatalogTemplateVersion) (*CatalogTemplateVersion, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*CatalogTemplateVersion, error)
	Get(name string, opts metav1.GetOptions) (*CatalogTemplateVersion, error)
	Update(*CatalogTemplateVersion) (*CatalogTemplateVersion, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*CatalogTemplateVersionList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*CatalogTemplateVersionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() CatalogTemplateVersionController
	AddHandler(ctx context.Context, name string, sync CatalogTemplateVersionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CatalogTemplateVersionHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle CatalogTemplateVersionLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle CatalogTemplateVersionLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CatalogTemplateVersionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync CatalogTemplateVersionHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CatalogTemplateVersionLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle CatalogTemplateVersionLifecycle)
}

type CatalogTemplateVersionLifecycle 

type CatalogTemplateVersionLifecycle interface {
	Create(obj *CatalogTemplateVersion) (runtime.Object, error)
	Remove(obj *CatalogTemplateVersion) (runtime.Object, error)
	Updated(obj *CatalogTemplateVersion) (runtime.Object, error)
}

type CatalogTemplateVersionList 

type CatalogTemplateVersionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []CatalogTemplateVersion `json:"items"`
}

func (*CatalogTemplateVersionList) DeepCopy 

func (in *CatalogTemplateVersionList) DeepCopy() *CatalogTemplateVersionList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CatalogTemplateVersionList.

func (*CatalogTemplateVersionList) DeepCopyInto 

func (in *CatalogTemplateVersionList) DeepCopyInto(out *CatalogTemplateVersionList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CatalogTemplateVersionList) DeepCopyObject 

func (in *CatalogTemplateVersionList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CatalogTemplateVersionLister 

type CatalogTemplateVersionLister interface {
	List(namespace string, selector labels.Selector) (ret []*CatalogTemplateVersion, err error)
	Get(namespace, name string) (*CatalogTemplateVersion, error)
}

type CatalogTemplateVersionsGetter 

type CatalogTemplateVersionsGetter interface {
	CatalogTemplateVersions(namespace string) CatalogTemplateVersionInterface
}

type CatalogTemplatesGetter 

type CatalogTemplatesGetter interface {
	CatalogTemplates(namespace string) CatalogTemplateInterface
}

type CatalogsGetter 

type CatalogsGetter interface {
	Catalogs(namespace string) CatalogInterface
}

type CertExpiration 

type CertExpiration struct {
	ExpirationDate string `json:"expirationDate,omitempty"`
}

func (*CertExpiration) DeepCopy 

func (in *CertExpiration) DeepCopy() *CertExpiration

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertExpiration.

func (*CertExpiration) DeepCopyInto 

func (in *CertExpiration) DeepCopyInto(out *CertExpiration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ChangePasswordInput 

type ChangePasswordInput struct {
	CurrentPassword string `json:"currentPassword" norman:"type=string,required"`
	NewPassword     string `json:"newPassword" norman:"type=string,required"`
}

func (*ChangePasswordInput) DeepCopy 

func (in *ChangePasswordInput) DeepCopy() *ChangePasswordInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ChangePasswordInput.

func (*ChangePasswordInput) DeepCopyInto 

func (in *ChangePasswordInput) DeepCopyInto(out *ChangePasswordInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CisBenchmarkVersion 

type CisBenchmarkVersion struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Info CisBenchmarkVersionInfo `json:"info" yaml:"info"`
}

func NewCisBenchmarkVersion 

func NewCisBenchmarkVersion(namespace, name string, obj CisBenchmarkVersion) *CisBenchmarkVersion

func (*CisBenchmarkVersion) DeepCopy 

func (in *CisBenchmarkVersion) DeepCopy() *CisBenchmarkVersion

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisBenchmarkVersion.

func (*CisBenchmarkVersion) DeepCopyInto 

func (in *CisBenchmarkVersion) DeepCopyInto(out *CisBenchmarkVersion)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CisBenchmarkVersion) DeepCopyObject 

func (in *CisBenchmarkVersion) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CisBenchmarkVersionChangeHandlerFunc 

type CisBenchmarkVersionChangeHandlerFunc func(obj *CisBenchmarkVersion) (runtime.Object, error)

type CisBenchmarkVersionController 

type CisBenchmarkVersionController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() CisBenchmarkVersionLister
	AddHandler(ctx context.Context, name string, handler CisBenchmarkVersionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CisBenchmarkVersionHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CisBenchmarkVersionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler CisBenchmarkVersionHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type CisBenchmarkVersionHandlerFunc 

type CisBenchmarkVersionHandlerFunc func(key string, obj *CisBenchmarkVersion) (runtime.Object, error)

func NewCisBenchmarkVersionLifecycleAdapter 

func NewCisBenchmarkVersionLifecycleAdapter(name string, clusterScoped bool, client CisBenchmarkVersionInterface, l CisBenchmarkVersionLifecycle) CisBenchmarkVersionHandlerFunc

type CisBenchmarkVersionInfo 

type CisBenchmarkVersionInfo struct {
	Managed              bool              `yaml:"managed" json:"managed"`
	MinKubernetesVersion string            `yaml:"min_kubernetes_version" json:"minKubernetesVersion"`
	SkippedChecks        map[string]string `yaml:"skipped_checks" json:"skippedChecks"`
	NotApplicableChecks  map[string]string `yaml:"not_applicable_checks" json:"notApplicableChecks"`
}

func (*CisBenchmarkVersionInfo) DeepCopy 

func (in *CisBenchmarkVersionInfo) DeepCopy() *CisBenchmarkVersionInfo

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisBenchmarkVersionInfo.

func (*CisBenchmarkVersionInfo) DeepCopyInto 

func (in *CisBenchmarkVersionInfo) DeepCopyInto(out *CisBenchmarkVersionInfo)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CisBenchmarkVersionInterface 

type CisBenchmarkVersionInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*CisBenchmarkVersion) (*CisBenchmarkVersion, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*CisBenchmarkVersion, error)
	Get(name string, opts metav1.GetOptions) (*CisBenchmarkVersion, error)
	Update(*CisBenchmarkVersion) (*CisBenchmarkVersion, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*CisBenchmarkVersionList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*CisBenchmarkVersionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() CisBenchmarkVersionController
	AddHandler(ctx context.Context, name string, sync CisBenchmarkVersionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CisBenchmarkVersionHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle CisBenchmarkVersionLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle CisBenchmarkVersionLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CisBenchmarkVersionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync CisBenchmarkVersionHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CisBenchmarkVersionLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle CisBenchmarkVersionLifecycle)
}

type CisBenchmarkVersionLifecycle 

type CisBenchmarkVersionLifecycle interface {
	Create(obj *CisBenchmarkVersion) (runtime.Object, error)
	Remove(obj *CisBenchmarkVersion) (runtime.Object, error)
	Updated(obj *CisBenchmarkVersion) (runtime.Object, error)
}

type CisBenchmarkVersionList 

type CisBenchmarkVersionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []CisBenchmarkVersion `json:"items"`
}

func (*CisBenchmarkVersionList) DeepCopy 

func (in *CisBenchmarkVersionList) DeepCopy() *CisBenchmarkVersionList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisBenchmarkVersionList.

func (*CisBenchmarkVersionList) DeepCopyInto 

func (in *CisBenchmarkVersionList) DeepCopyInto(out *CisBenchmarkVersionList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CisBenchmarkVersionList) DeepCopyObject 

func (in *CisBenchmarkVersionList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CisBenchmarkVersionLister 

type CisBenchmarkVersionLister interface {
	List(namespace string, selector labels.Selector) (ret []*CisBenchmarkVersion, err error)
	Get(namespace, name string) (*CisBenchmarkVersion, error)
}

type CisBenchmarkVersionsGetter 

type CisBenchmarkVersionsGetter interface {
	CisBenchmarkVersions(namespace string) CisBenchmarkVersionInterface
}

type CisConfig 

type CisConfig struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Params CisConfigParams `yaml:"params" json:"params,omitempty"`
}

func NewCisConfig 

func NewCisConfig(namespace, name string, obj CisConfig) *CisConfig

func (*CisConfig) DeepCopy 

func (in *CisConfig) DeepCopy() *CisConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisConfig.

func (*CisConfig) DeepCopyInto 

func (in *CisConfig) DeepCopyInto(out *CisConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CisConfig) DeepCopyObject 

func (in *CisConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CisConfigChangeHandlerFunc 

type CisConfigChangeHandlerFunc func(obj *CisConfig) (runtime.Object, error)

type CisConfigController 

type CisConfigController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() CisConfigLister
	AddHandler(ctx context.Context, name string, handler CisConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CisConfigHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CisConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler CisConfigHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type CisConfigHandlerFunc 

type CisConfigHandlerFunc func(key string, obj *CisConfig) (runtime.Object, error)

func NewCisConfigLifecycleAdapter 

func NewCisConfigLifecycleAdapter(name string, clusterScoped bool, client CisConfigInterface, l CisConfigLifecycle) CisConfigHandlerFunc

type CisConfigInterface 

type CisConfigInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*CisConfig) (*CisConfig, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*CisConfig, error)
	Get(name string, opts metav1.GetOptions) (*CisConfig, error)
	Update(*CisConfig) (*CisConfig, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*CisConfigList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*CisConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() CisConfigController
	AddHandler(ctx context.Context, name string, sync CisConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CisConfigHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle CisConfigLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle CisConfigLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CisConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync CisConfigHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CisConfigLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle CisConfigLifecycle)
}

type CisConfigLifecycle 

type CisConfigLifecycle interface {
	Create(obj *CisConfig) (runtime.Object, error)
	Remove(obj *CisConfig) (runtime.Object, error)
	Updated(obj *CisConfig) (runtime.Object, error)
}

type CisConfigList 

type CisConfigList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []CisConfig `json:"items"`
}

func (*CisConfigList) DeepCopy 

func (in *CisConfigList) DeepCopy() *CisConfigList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisConfigList.

func (*CisConfigList) DeepCopyInto 

func (in *CisConfigList) DeepCopyInto(out *CisConfigList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CisConfigList) DeepCopyObject 

func (in *CisConfigList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CisConfigLister 

type CisConfigLister interface {
	List(namespace string, selector labels.Selector) (ret []*CisConfig, err error)
	Get(namespace, name string) (*CisConfig, error)
}

type CisConfigParams 

type CisConfigParams struct {
	BenchmarkVersion string `yaml:"benchmark_version" json:"benchmarkVersion"`
}

func (*CisConfigParams) DeepCopy 

func (in *CisConfigParams) DeepCopy() *CisConfigParams

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisConfigParams.

func (*CisConfigParams) DeepCopyInto 

func (in *CisConfigParams) DeepCopyInto(out *CisConfigParams)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CisConfigsGetter 

type CisConfigsGetter interface {
	CisConfigs(namespace string) CisConfigInterface
}

type CisScanConfig 

type CisScanConfig struct {
	// IDs of the checks that need to be skipped in the final report
	OverrideSkip []string `json:"overrideSkip"`
	// Override the CIS benchmark version to use for the scan (instead of latest)
	OverrideBenchmarkVersion string `json:"overrideBenchmarkVersion,omitempty"`
	// scan profile to use
	Profile CisScanProfileType `json:"profile,omitempty" norman:"required,options=permissive|hardened,default=permissive"`
	// Internal flag for debugging master component of the scan
	DebugMaster bool `json:"debugMaster"`
	// Internal flag for debugging worker component of the scan
	DebugWorker bool `json:"debugWorker"`
}

func (*CisScanConfig) DeepCopy 

func (in *CisScanConfig) DeepCopy() *CisScanConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisScanConfig.

func (*CisScanConfig) DeepCopyInto 

func (in *CisScanConfig) DeepCopyInto(out *CisScanConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CisScanProfileType 

type CisScanProfileType string

type CisScanStatus 

type CisScanStatus struct {
	Total         int `json:"total"`
	Pass          int `json:"pass"`
	Fail          int `json:"fail"`
	Skip          int `json:"skip"`
	NotApplicable int `json:"notApplicable"`
}

func (*CisScanStatus) DeepCopy 

func (in *CisScanStatus) DeepCopy() *CisScanStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CisScanStatus.

func (*CisScanStatus) DeepCopyInto 

func (in *CisScanStatus) DeepCopyInto(out *CisScanStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Client 

type Client struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func (*Client) AuthConfigs 

func (c *Client) AuthConfigs(namespace string) AuthConfigInterface

func (*Client) CatalogTemplateVersions 

func (c *Client) CatalogTemplateVersions(namespace string) CatalogTemplateVersionInterface

func (*Client) CatalogTemplates 

func (c *Client) CatalogTemplates(namespace string) CatalogTemplateInterface

func (*Client) Catalogs 

func (c *Client) Catalogs(namespace string) CatalogInterface

func (*Client) CisBenchmarkVersions 

func (c *Client) CisBenchmarkVersions(namespace string) CisBenchmarkVersionInterface

func (*Client) CisConfigs 

func (c *Client) CisConfigs(namespace string) CisConfigInterface

func (*Client) CloudCredentials 

func (c *Client) CloudCredentials(namespace string) CloudCredentialInterface

func (*Client) ClusterAlertGroups 

func (c *Client) ClusterAlertGroups(namespace string) ClusterAlertGroupInterface

func (*Client) ClusterAlertRules 

func (c *Client) ClusterAlertRules(namespace string) ClusterAlertRuleInterface

func (*Client) ClusterAlerts 

func (c *Client) ClusterAlerts(namespace string) ClusterAlertInterface

func (*Client) ClusterCatalogs 

func (c *Client) ClusterCatalogs(namespace string) ClusterCatalogInterface

func (*Client) ClusterLoggings 

func (c *Client) ClusterLoggings(namespace string) ClusterLoggingInterface

func (*Client) ClusterMonitorGraphs 

func (c *Client) ClusterMonitorGraphs(namespace string) ClusterMonitorGraphInterface

func (*Client) ClusterRegistrationTokens 

func (c *Client) ClusterRegistrationTokens(namespace string) ClusterRegistrationTokenInterface

func (*Client) ClusterRoleTemplateBindings 

func (c *Client) ClusterRoleTemplateBindings(namespace string) ClusterRoleTemplateBindingInterface

func (*Client) ClusterScans 

func (c *Client) ClusterScans(namespace string) ClusterScanInterface

func (*Client) ClusterTemplateRevisions 

func (c *Client) ClusterTemplateRevisions(namespace string) ClusterTemplateRevisionInterface

func (*Client) ClusterTemplates 

func (c *Client) ClusterTemplates(namespace string) ClusterTemplateInterface

func (*Client) Clusters 

func (c *Client) Clusters(namespace string) ClusterInterface

func (*Client) ComposeConfigs 

func (c *Client) ComposeConfigs(namespace string) ComposeConfigInterface

func (*Client) DynamicSchemas 

func (c *Client) DynamicSchemas(namespace string) DynamicSchemaInterface

func (*Client) EtcdBackups 

func (c *Client) EtcdBackups(namespace string) EtcdBackupInterface

func (*Client) Features 

func (c *Client) Features(namespace string) FeatureInterface

func (*Client) GlobalDNSProviders 

func (c *Client) GlobalDNSProviders(namespace string) GlobalDNSProviderInterface

func (*Client) GlobalDNSs 

func (c *Client) GlobalDNSs(namespace string) GlobalDNSInterface

func (*Client) GlobalRoleBindings 

func (c *Client) GlobalRoleBindings(namespace string) GlobalRoleBindingInterface

func (*Client) GlobalRoles 

func (c *Client) GlobalRoles(namespace string) GlobalRoleInterface

func (*Client) GroupMembers 

func (c *Client) GroupMembers(namespace string) GroupMemberInterface

func (*Client) Groups 

func (c *Client) Groups(namespace string) GroupInterface

func (*Client) KontainerDrivers 

func (c *Client) KontainerDrivers(namespace string) KontainerDriverInterface

func (*Client) LdapConfigs 

func (c *Client) LdapConfigs(namespace string) LdapConfigInterface

func (*Client) MonitorMetrics 

func (c *Client) MonitorMetrics(namespace string) MonitorMetricInterface

func (*Client) MultiClusterAppRevisions 

func (c *Client) MultiClusterAppRevisions(namespace string) MultiClusterAppRevisionInterface

func (*Client) MultiClusterApps 

func (c *Client) MultiClusterApps(namespace string) MultiClusterAppInterface

func (*Client) NodeDrivers 

func (c *Client) NodeDrivers(namespace string) NodeDriverInterface

func (*Client) NodePools 

func (c *Client) NodePools(namespace string) NodePoolInterface

func (*Client) NodeTemplates 

func (c *Client) NodeTemplates(namespace string) NodeTemplateInterface

func (*Client) Nodes 

func (c *Client) Nodes(namespace string) NodeInterface

func (*Client) Notifiers 

func (c *Client) Notifiers(namespace string) NotifierInterface

func (*Client) PodSecurityPolicyTemplateProjectBindings 

func (c *Client) PodSecurityPolicyTemplateProjectBindings(namespace string) PodSecurityPolicyTemplateProjectBindingInterface

func (*Client) PodSecurityPolicyTemplates 

func (c *Client) PodSecurityPolicyTemplates(namespace string) PodSecurityPolicyTemplateInterface

func (*Client) Preferences 

func (c *Client) Preferences(namespace string) PreferenceInterface

func (*Client) Principals 

func (c *Client) Principals(namespace string) PrincipalInterface

func (*Client) ProjectAlertGroups 

func (c *Client) ProjectAlertGroups(namespace string) ProjectAlertGroupInterface

func (*Client) ProjectAlertRules 

func (c *Client) ProjectAlertRules(namespace string) ProjectAlertRuleInterface

func (*Client) ProjectAlerts 

func (c *Client) ProjectAlerts(namespace string) ProjectAlertInterface

func (*Client) ProjectCatalogs 

func (c *Client) ProjectCatalogs(namespace string) ProjectCatalogInterface

func (*Client) ProjectLoggings 

func (c *Client) ProjectLoggings(namespace string) ProjectLoggingInterface

func (*Client) ProjectMonitorGraphs 

func (c *Client) ProjectMonitorGraphs(namespace string) ProjectMonitorGraphInterface

func (*Client) ProjectNetworkPolicies 

func (c *Client) ProjectNetworkPolicies(namespace string) ProjectNetworkPolicyInterface

func (*Client) ProjectRoleTemplateBindings 

func (c *Client) ProjectRoleTemplateBindings(namespace string) ProjectRoleTemplateBindingInterface

func (*Client) Projects 

func (c *Client) Projects(namespace string) ProjectInterface

func (*Client) RESTClient 

func (c *Client) RESTClient() rest.Interface

func (*Client) RKEAddons 

func (c *Client) RKEAddons(namespace string) RKEAddonInterface

func (*Client) RKEK8sServiceOptions 

func (c *Client) RKEK8sServiceOptions(namespace string) RKEK8sServiceOptionInterface

func (*Client) RKEK8sSystemImages 

func (c *Client) RKEK8sSystemImages(namespace string) RKEK8sSystemImageInterface

func (*Client) RoleTemplates 

func (c *Client) RoleTemplates(namespace string) RoleTemplateInterface

func (*Client) SamlTokens 

func (c *Client) SamlTokens(namespace string) SamlTokenInterface

func (*Client) Settings 

func (c *Client) Settings(namespace string) SettingInterface

func (*Client) Start 

func (c *Client) Start(ctx context.Context, threadiness int) error

func (*Client) Sync 

func (c *Client) Sync(ctx context.Context) error

func (*Client) TemplateContents 

func (c *Client) TemplateContents(namespace string) TemplateContentInterface

func (*Client) TemplateVersions 

func (c *Client) TemplateVersions(namespace string) TemplateVersionInterface

func (*Client) Templates 

func (c *Client) Templates(namespace string) TemplateInterface

func (*Client) Tokens 

func (c *Client) Tokens(namespace string) TokenInterface

func (*Client) UserAttributes 

func (c *Client) UserAttributes(namespace string) UserAttributeInterface

func (*Client) Users 

func (c *Client) Users(namespace string) UserInterface

type CloudCredential 

type CloudCredential struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`

	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec CloudCredentialSpec `json:"spec"`
}

func NewCloudCredential 

func NewCloudCredential(namespace, name string, obj CloudCredential) *CloudCredential

func (*CloudCredential) DeepCopy 

func (in *CloudCredential) DeepCopy() *CloudCredential

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudCredential.

func (*CloudCredential) DeepCopyInto 

func (in *CloudCredential) DeepCopyInto(out *CloudCredential)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CloudCredential) DeepCopyObject 

func (in *CloudCredential) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CloudCredentialChangeHandlerFunc 

type CloudCredentialChangeHandlerFunc func(obj *CloudCredential) (runtime.Object, error)

type CloudCredentialController 

type CloudCredentialController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() CloudCredentialLister
	AddHandler(ctx context.Context, name string, handler CloudCredentialHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CloudCredentialHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CloudCredentialHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler CloudCredentialHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type CloudCredentialHandlerFunc 

type CloudCredentialHandlerFunc func(key string, obj *CloudCredential) (runtime.Object, error)

func NewCloudCredentialLifecycleAdapter 

func NewCloudCredentialLifecycleAdapter(name string, clusterScoped bool, client CloudCredentialInterface, l CloudCredentialLifecycle) CloudCredentialHandlerFunc

type CloudCredentialInterface 

type CloudCredentialInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*CloudCredential) (*CloudCredential, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*CloudCredential, error)
	Get(name string, opts metav1.GetOptions) (*CloudCredential, error)
	Update(*CloudCredential) (*CloudCredential, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*CloudCredentialList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*CloudCredentialList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() CloudCredentialController
	AddHandler(ctx context.Context, name string, sync CloudCredentialHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync CloudCredentialHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle CloudCredentialLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle CloudCredentialLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CloudCredentialHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync CloudCredentialHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CloudCredentialLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle CloudCredentialLifecycle)
}

type CloudCredentialLifecycle 

type CloudCredentialLifecycle interface {
	Create(obj *CloudCredential) (runtime.Object, error)
	Remove(obj *CloudCredential) (runtime.Object, error)
	Updated(obj *CloudCredential) (runtime.Object, error)
}

type CloudCredentialList 

type CloudCredentialList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []CloudCredential `json:"items"`
}

func (*CloudCredentialList) DeepCopy 

func (in *CloudCredentialList) DeepCopy() *CloudCredentialList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudCredentialList.

func (*CloudCredentialList) DeepCopyInto 

func (in *CloudCredentialList) DeepCopyInto(out *CloudCredentialList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*CloudCredentialList) DeepCopyObject 

func (in *CloudCredentialList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type CloudCredentialLister 

type CloudCredentialLister interface {
	List(namespace string, selector labels.Selector) (ret []*CloudCredential, err error)
	Get(namespace, name string) (*CloudCredential, error)
}

type CloudCredentialSpec 

type CloudCredentialSpec struct {
	DisplayName string `json:"displayName"`
	Description string `json:"description,omitempty"`
}

func (*CloudCredentialSpec) DeepCopy 

func (in *CloudCredentialSpec) DeepCopy() *CloudCredentialSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudCredentialSpec.

func (*CloudCredentialSpec) DeepCopyInto 

func (in *CloudCredentialSpec) DeepCopyInto(out *CloudCredentialSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CloudCredentialsGetter 

type CloudCredentialsGetter interface {
	CloudCredentials(namespace string) CloudCredentialInterface
}

type CloudProvider 

type CloudProvider struct {
	// Name of the Cloud Provider
	Name string `yaml:"name" json:"name,omitempty"`
	// AWSCloudProvider
	AWSCloudProvider *AWSCloudProvider `yaml:"awsCloudProvider,omitempty" json:"awsCloudProvider,omitempty"`
	// AzureCloudProvider
	AzureCloudProvider *AzureCloudProvider `yaml:"azureCloudProvider,omitempty" json:"azureCloudProvider,omitempty"`
	// OpenstackCloudProvider
	OpenstackCloudProvider *OpenstackCloudProvider `yaml:"openstackCloudProvider,omitempty" json:"openstackCloudProvider,omitempty"`
	// VsphereCloudProvider
	VsphereCloudProvider *VsphereCloudProvider `yaml:"vsphereCloudProvider,omitempty" json:"vsphereCloudProvider,omitempty"`
	// CustomCloudProvider is a multiline string that represent a custom cloud config file
	CustomCloudProvider string `yaml:"customCloudProvider,omitempty" json:"customCloudProvider,omitempty"`
}

func (*CloudProvider) DeepCopy 

func (in *CloudProvider) DeepCopy() *CloudProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudProvider.

func (*CloudProvider) DeepCopyInto 

func (in *CloudProvider) DeepCopyInto(out *CloudProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CloudflareProviderConfig 

type CloudflareProviderConfig struct {
	APIKey            string            `json:"apiKey" norman:"notnullable,required,minLength=1,type=password"`
	APIEmail          string            `json:"apiEmail" norman:"notnullable,required,minLength=1"`
	ProxySetting      *bool             `json:"proxySetting" norman:"default=true"`
	AdditionalOptions map[string]string `json:"additionalOptions,omitempty"`
}

func (*CloudflareProviderConfig) DeepCopy 

func (in *CloudflareProviderConfig) DeepCopy() *CloudflareProviderConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudflareProviderConfig.

func (*CloudflareProviderConfig) DeepCopyInto 

func (in *CloudflareProviderConfig) DeepCopyInto(out *CloudflareProviderConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Cluster 

type Cluster struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec ClusterSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status ClusterStatus `json:"status"`
}

func NewCluster 

func NewCluster(namespace, name string, obj Cluster) *Cluster

func (*Cluster) DeepCopy 

func (in *Cluster) DeepCopy() *Cluster

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Cluster.

func (*Cluster) DeepCopyInto 

func (in *Cluster) DeepCopyInto(out *Cluster)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Cluster) DeepCopyObject 

func (in *Cluster) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterAlert 

type ClusterAlert struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ClusterAlertSpec `json:"spec"`
	// Most recent observed status of the alert. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status AlertStatus `json:"status"`
}

func NewClusterAlert 

func NewClusterAlert(namespace, name string, obj ClusterAlert) *ClusterAlert

func (*ClusterAlert) DeepCopy 

func (in *ClusterAlert) DeepCopy() *ClusterAlert

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlert.

func (*ClusterAlert) DeepCopyInto 

func (in *ClusterAlert) DeepCopyInto(out *ClusterAlert)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlert) DeepCopyObject 

func (in *ClusterAlert) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterAlert) ObjClusterName 

func (c *ClusterAlert) ObjClusterName() string

type ClusterAlertChangeHandlerFunc 

type ClusterAlertChangeHandlerFunc func(obj *ClusterAlert) (runtime.Object, error)

type ClusterAlertController 

type ClusterAlertController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterAlertLister
	AddHandler(ctx context.Context, name string, handler ClusterAlertHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterAlertHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterAlertHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterAlertHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterAlertGroup 

type ClusterAlertGroup struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ClusterGroupSpec `json:"spec"`
	// Most recent observed status of the alert. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status AlertStatus `json:"status"`
}

func NewClusterAlertGroup 

func NewClusterAlertGroup(namespace, name string, obj ClusterAlertGroup) *ClusterAlertGroup

func (*ClusterAlertGroup) DeepCopy 

func (in *ClusterAlertGroup) DeepCopy() *ClusterAlertGroup

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlertGroup.

func (*ClusterAlertGroup) DeepCopyInto 

func (in *ClusterAlertGroup) DeepCopyInto(out *ClusterAlertGroup)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlertGroup) DeepCopyObject 

func (in *ClusterAlertGroup) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterAlertGroup) ObjClusterName 

func (c *ClusterAlertGroup) ObjClusterName() string

type ClusterAlertGroupChangeHandlerFunc 

type ClusterAlertGroupChangeHandlerFunc func(obj *ClusterAlertGroup) (runtime.Object, error)

type ClusterAlertGroupController 

type ClusterAlertGroupController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterAlertGroupLister
	AddHandler(ctx context.Context, name string, handler ClusterAlertGroupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterAlertGroupHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterAlertGroupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterAlertGroupHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterAlertGroupHandlerFunc 

type ClusterAlertGroupHandlerFunc func(key string, obj *ClusterAlertGroup) (runtime.Object, error)

func NewClusterAlertGroupLifecycleAdapter 

func NewClusterAlertGroupLifecycleAdapter(name string, clusterScoped bool, client ClusterAlertGroupInterface, l ClusterAlertGroupLifecycle) ClusterAlertGroupHandlerFunc

type ClusterAlertGroupInterface 

type ClusterAlertGroupInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterAlertGroup) (*ClusterAlertGroup, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterAlertGroup, error)
	Get(name string, opts metav1.GetOptions) (*ClusterAlertGroup, error)
	Update(*ClusterAlertGroup) (*ClusterAlertGroup, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterAlertGroupList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterAlertGroupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterAlertGroupController
	AddHandler(ctx context.Context, name string, sync ClusterAlertGroupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterAlertGroupHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterAlertGroupLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterAlertGroupLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterAlertGroupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterAlertGroupHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterAlertGroupLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterAlertGroupLifecycle)
}

type ClusterAlertGroupLifecycle 

type ClusterAlertGroupLifecycle interface {
	Create(obj *ClusterAlertGroup) (runtime.Object, error)
	Remove(obj *ClusterAlertGroup) (runtime.Object, error)
	Updated(obj *ClusterAlertGroup) (runtime.Object, error)
}

type ClusterAlertGroupList 

type ClusterAlertGroupList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterAlertGroup `json:"items"`
}

func (*ClusterAlertGroupList) DeepCopy 

func (in *ClusterAlertGroupList) DeepCopy() *ClusterAlertGroupList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlertGroupList.

func (*ClusterAlertGroupList) DeepCopyInto 

func (in *ClusterAlertGroupList) DeepCopyInto(out *ClusterAlertGroupList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlertGroupList) DeepCopyObject 

func (in *ClusterAlertGroupList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterAlertGroupLister 

type ClusterAlertGroupLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterAlertGroup, err error)
	Get(namespace, name string) (*ClusterAlertGroup, error)
}

type ClusterAlertGroupsGetter 

type ClusterAlertGroupsGetter interface {
	ClusterAlertGroups(namespace string) ClusterAlertGroupInterface
}

type ClusterAlertHandlerFunc 

type ClusterAlertHandlerFunc func(key string, obj *ClusterAlert) (runtime.Object, error)

func NewClusterAlertLifecycleAdapter 

func NewClusterAlertLifecycleAdapter(name string, clusterScoped bool, client ClusterAlertInterface, l ClusterAlertLifecycle) ClusterAlertHandlerFunc

type ClusterAlertInterface 

type ClusterAlertInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterAlert) (*ClusterAlert, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterAlert, error)
	Get(name string, opts metav1.GetOptions) (*ClusterAlert, error)
	Update(*ClusterAlert) (*ClusterAlert, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterAlertList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterAlertList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterAlertController
	AddHandler(ctx context.Context, name string, sync ClusterAlertHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterAlertHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterAlertLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterAlertLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterAlertHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterAlertHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterAlertLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterAlertLifecycle)
}

type ClusterAlertLifecycle 

type ClusterAlertLifecycle interface {
	Create(obj *ClusterAlert) (runtime.Object, error)
	Remove(obj *ClusterAlert) (runtime.Object, error)
	Updated(obj *ClusterAlert) (runtime.Object, error)
}

type ClusterAlertList 

type ClusterAlertList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterAlert `json:"items"`
}

func (*ClusterAlertList) DeepCopy 

func (in *ClusterAlertList) DeepCopy() *ClusterAlertList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlertList.

func (*ClusterAlertList) DeepCopyInto 

func (in *ClusterAlertList) DeepCopyInto(out *ClusterAlertList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlertList) DeepCopyObject 

func (in *ClusterAlertList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterAlertLister 

type ClusterAlertLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterAlert, err error)
	Get(namespace, name string) (*ClusterAlert, error)
}

type ClusterAlertRule 

type ClusterAlertRule struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ClusterAlertRuleSpec `json:"spec"`
	// Most recent observed status of the alert. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status AlertStatus `json:"status"`
}

func NewClusterAlertRule 

func NewClusterAlertRule(namespace, name string, obj ClusterAlertRule) *ClusterAlertRule

func (*ClusterAlertRule) DeepCopy 

func (in *ClusterAlertRule) DeepCopy() *ClusterAlertRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlertRule.

func (*ClusterAlertRule) DeepCopyInto 

func (in *ClusterAlertRule) DeepCopyInto(out *ClusterAlertRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlertRule) DeepCopyObject 

func (in *ClusterAlertRule) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterAlertRule) ObjClusterName 

func (c *ClusterAlertRule) ObjClusterName() string

type ClusterAlertRuleChangeHandlerFunc 

type ClusterAlertRuleChangeHandlerFunc func(obj *ClusterAlertRule) (runtime.Object, error)

type ClusterAlertRuleController 

type ClusterAlertRuleController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterAlertRuleLister
	AddHandler(ctx context.Context, name string, handler ClusterAlertRuleHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterAlertRuleHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterAlertRuleHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterAlertRuleHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterAlertRuleHandlerFunc 

type ClusterAlertRuleHandlerFunc func(key string, obj *ClusterAlertRule) (runtime.Object, error)

func NewClusterAlertRuleLifecycleAdapter 

func NewClusterAlertRuleLifecycleAdapter(name string, clusterScoped bool, client ClusterAlertRuleInterface, l ClusterAlertRuleLifecycle) ClusterAlertRuleHandlerFunc

type ClusterAlertRuleInterface 

type ClusterAlertRuleInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterAlertRule) (*ClusterAlertRule, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterAlertRule, error)
	Get(name string, opts metav1.GetOptions) (*ClusterAlertRule, error)
	Update(*ClusterAlertRule) (*ClusterAlertRule, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterAlertRuleList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterAlertRuleList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterAlertRuleController
	AddHandler(ctx context.Context, name string, sync ClusterAlertRuleHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterAlertRuleHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterAlertRuleLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterAlertRuleLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterAlertRuleHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterAlertRuleHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterAlertRuleLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterAlertRuleLifecycle)
}

type ClusterAlertRuleLifecycle 

type ClusterAlertRuleLifecycle interface {
	Create(obj *ClusterAlertRule) (runtime.Object, error)
	Remove(obj *ClusterAlertRule) (runtime.Object, error)
	Updated(obj *ClusterAlertRule) (runtime.Object, error)
}

type ClusterAlertRuleList 

type ClusterAlertRuleList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterAlertRule `json:"items"`
}

func (*ClusterAlertRuleList) DeepCopy 

func (in *ClusterAlertRuleList) DeepCopy() *ClusterAlertRuleList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlertRuleList.

func (*ClusterAlertRuleList) DeepCopyInto 

func (in *ClusterAlertRuleList) DeepCopyInto(out *ClusterAlertRuleList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlertRuleList) DeepCopyObject 

func (in *ClusterAlertRuleList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterAlertRuleLister 

type ClusterAlertRuleLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterAlertRule, err error)
	Get(namespace, name string) (*ClusterAlertRule, error)
}

type ClusterAlertRuleSpec 

type ClusterAlertRuleSpec struct {
	CommonRuleField
	ClusterName       string             `json:"clusterName" norman:"type=reference[cluster]"`
	GroupName         string             `json:"groupName" norman:"type=reference[clusterAlertGroup]"`
	NodeRule          *NodeRule          `json:"nodeRule,omitempty"`
	EventRule         *EventRule         `json:"eventRule,omitempty"`
	SystemServiceRule *SystemServiceRule `json:"systemServiceRule,omitempty"`
	MetricRule        *MetricRule        `json:"metricRule,omitempty"`
	ClusterScanRule   *ClusterScanRule   `json:"clusterScanRule,omitempty"`
}

func (*ClusterAlertRuleSpec) DeepCopy 

func (in *ClusterAlertRuleSpec) DeepCopy() *ClusterAlertRuleSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlertRuleSpec.

func (*ClusterAlertRuleSpec) DeepCopyInto 

func (in *ClusterAlertRuleSpec) DeepCopyInto(out *ClusterAlertRuleSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlertRuleSpec) ObjClusterName 

func (c *ClusterAlertRuleSpec) ObjClusterName() string

type ClusterAlertRulesGetter 

type ClusterAlertRulesGetter interface {
	ClusterAlertRules(namespace string) ClusterAlertRuleInterface
}

type ClusterAlertSpec 

type ClusterAlertSpec struct {
	AlertCommonSpec

	ClusterName         string               `json:"clusterName" norman:"type=reference[cluster]"`
	TargetNode          *TargetNode          `json:"targetNode,omitempty"`
	TargetSystemService *TargetSystemService `json:"targetSystemService,omitempty"`
	TargetEvent         *TargetEvent         `json:"targetEvent,omitempty"`
}

func (*ClusterAlertSpec) DeepCopy 

func (in *ClusterAlertSpec) DeepCopy() *ClusterAlertSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAlertSpec.

func (*ClusterAlertSpec) DeepCopyInto 

func (in *ClusterAlertSpec) DeepCopyInto(out *ClusterAlertSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterAlertSpec) ObjClusterName 

func (c *ClusterAlertSpec) ObjClusterName() string

type ClusterAlertsGetter 

type ClusterAlertsGetter interface {
	ClusterAlerts(namespace string) ClusterAlertInterface
}

type ClusterCatalog 

type ClusterCatalog struct {
	types.Namespaced

	Catalog     `json:",inline" mapstructure:",squash"`
	ClusterName string `json:"clusterName,omitempty" norman:"required,type=reference[cluster]"`
}

func NewClusterCatalog 

func NewClusterCatalog(namespace, name string, obj ClusterCatalog) *ClusterCatalog

func (*ClusterCatalog) DeepCopy 

func (in *ClusterCatalog) DeepCopy() *ClusterCatalog

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterCatalog.

func (*ClusterCatalog) DeepCopyInto 

func (in *ClusterCatalog) DeepCopyInto(out *ClusterCatalog)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterCatalog) DeepCopyObject 

func (in *ClusterCatalog) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterCatalogChangeHandlerFunc 

type ClusterCatalogChangeHandlerFunc func(obj *ClusterCatalog) (runtime.Object, error)

type ClusterCatalogController 

type ClusterCatalogController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterCatalogLister
	AddHandler(ctx context.Context, name string, handler ClusterCatalogHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterCatalogHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterCatalogHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterCatalogHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterCatalogHandlerFunc 

type ClusterCatalogHandlerFunc func(key string, obj *ClusterCatalog) (runtime.Object, error)

func NewClusterCatalogLifecycleAdapter 

func NewClusterCatalogLifecycleAdapter(name string, clusterScoped bool, client ClusterCatalogInterface, l ClusterCatalogLifecycle) ClusterCatalogHandlerFunc

type ClusterCatalogInterface 

type ClusterCatalogInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterCatalog) (*ClusterCatalog, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterCatalog, error)
	Get(name string, opts metav1.GetOptions) (*ClusterCatalog, error)
	Update(*ClusterCatalog) (*ClusterCatalog, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterCatalogList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterCatalogList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterCatalogController
	AddHandler(ctx context.Context, name string, sync ClusterCatalogHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterCatalogHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterCatalogLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterCatalogLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterCatalogHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterCatalogHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterCatalogLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterCatalogLifecycle)
}

type ClusterCatalogLifecycle 

type ClusterCatalogLifecycle interface {
	Create(obj *ClusterCatalog) (runtime.Object, error)
	Remove(obj *ClusterCatalog) (runtime.Object, error)
	Updated(obj *ClusterCatalog) (runtime.Object, error)
}

type ClusterCatalogList 

type ClusterCatalogList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterCatalog `json:"items"`
}

func (*ClusterCatalogList) DeepCopy 

func (in *ClusterCatalogList) DeepCopy() *ClusterCatalogList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterCatalogList.

func (*ClusterCatalogList) DeepCopyInto 

func (in *ClusterCatalogList) DeepCopyInto(out *ClusterCatalogList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterCatalogList) DeepCopyObject 

func (in *ClusterCatalogList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterCatalogLister 

type ClusterCatalogLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterCatalog, err error)
	Get(namespace, name string) (*ClusterCatalog, error)
}

type ClusterCatalogsGetter 

type ClusterCatalogsGetter interface {
	ClusterCatalogs(namespace string) ClusterCatalogInterface
}

type ClusterChangeHandlerFunc 

type ClusterChangeHandlerFunc func(obj *Cluster) (runtime.Object, error)

type ClusterComponentStatus 

type ClusterComponentStatus struct {
	Name       string                  `json:"name"`
	Conditions []v1.ComponentCondition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,2,rep,name=conditions"`
}

func (*ClusterComponentStatus) DeepCopy 

func (in *ClusterComponentStatus) DeepCopy() *ClusterComponentStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterComponentStatus.

func (*ClusterComponentStatus) DeepCopyInto 

func (in *ClusterComponentStatus) DeepCopyInto(out *ClusterComponentStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterCondition 

type ClusterCondition struct {
	// Type of cluster condition.
	Type ClusterConditionType `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*ClusterCondition) DeepCopy 

func (in *ClusterCondition) DeepCopy() *ClusterCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterCondition.

func (*ClusterCondition) DeepCopyInto 

func (in *ClusterCondition) DeepCopyInto(out *ClusterCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterConditionType 

type ClusterConditionType string

type ClusterController 

type ClusterController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterLister
	AddHandler(ctx context.Context, name string, handler ClusterHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterGroupSpec 

type ClusterGroupSpec struct {
	ClusterName string      `json:"clusterName" norman:"type=reference[cluster]"`
	Recipients  []Recipient `json:"recipients,omitempty"`
	CommonGroupField
}

func (*ClusterGroupSpec) DeepCopy 

func (in *ClusterGroupSpec) DeepCopy() *ClusterGroupSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterGroupSpec.

func (*ClusterGroupSpec) DeepCopyInto 

func (in *ClusterGroupSpec) DeepCopyInto(out *ClusterGroupSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterGroupSpec) ObjClusterName 

func (c *ClusterGroupSpec) ObjClusterName() string

type ClusterHandlerFunc 

type ClusterHandlerFunc func(key string, obj *Cluster) (runtime.Object, error)

func NewClusterLifecycleAdapter 

func NewClusterLifecycleAdapter(name string, clusterScoped bool, client ClusterInterface, l ClusterLifecycle) ClusterHandlerFunc

type ClusterInterface 

type ClusterInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Cluster) (*Cluster, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Cluster, error)
	Get(name string, opts metav1.GetOptions) (*Cluster, error)
	Update(*Cluster) (*Cluster, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterController
	AddHandler(ctx context.Context, name string, sync ClusterHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterLifecycle)
}

type ClusterLifecycle 

type ClusterLifecycle interface {
	Create(obj *Cluster) (runtime.Object, error)
	Remove(obj *Cluster) (runtime.Object, error)
	Updated(obj *Cluster) (runtime.Object, error)
}

type ClusterList 

type ClusterList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Cluster `json:"items"`
}

func (*ClusterList) DeepCopy 

func (in *ClusterList) DeepCopy() *ClusterList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterList.

func (*ClusterList) DeepCopyInto 

func (in *ClusterList) DeepCopyInto(out *ClusterList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterList) DeepCopyObject 

func (in *ClusterList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterLister 

type ClusterLister interface {
	List(namespace string, selector labels.Selector) (ret []*Cluster, err error)
	Get(namespace, name string) (*Cluster, error)
}

type ClusterLogging 

type ClusterLogging struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec ClusterLoggingSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status ClusterLoggingStatus `json:"status"`
}

func NewClusterLogging 

func NewClusterLogging(namespace, name string, obj ClusterLogging) *ClusterLogging

func (*ClusterLogging) DeepCopy 

func (in *ClusterLogging) DeepCopy() *ClusterLogging

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterLogging.

func (*ClusterLogging) DeepCopyInto 

func (in *ClusterLogging) DeepCopyInto(out *ClusterLogging)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterLogging) DeepCopyObject 

func (in *ClusterLogging) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterLogging) ObjClusterName 

func (c *ClusterLogging) ObjClusterName() string

type ClusterLoggingChangeHandlerFunc 

type ClusterLoggingChangeHandlerFunc func(obj *ClusterLogging) (runtime.Object, error)

type ClusterLoggingController 

type ClusterLoggingController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterLoggingLister
	AddHandler(ctx context.Context, name string, handler ClusterLoggingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterLoggingHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterLoggingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterLoggingHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterLoggingHandlerFunc 

type ClusterLoggingHandlerFunc func(key string, obj *ClusterLogging) (runtime.Object, error)

func NewClusterLoggingLifecycleAdapter 

func NewClusterLoggingLifecycleAdapter(name string, clusterScoped bool, client ClusterLoggingInterface, l ClusterLoggingLifecycle) ClusterLoggingHandlerFunc

type ClusterLoggingInterface 

type ClusterLoggingInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterLogging) (*ClusterLogging, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterLogging, error)
	Get(name string, opts metav1.GetOptions) (*ClusterLogging, error)
	Update(*ClusterLogging) (*ClusterLogging, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterLoggingList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterLoggingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterLoggingController
	AddHandler(ctx context.Context, name string, sync ClusterLoggingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterLoggingHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterLoggingLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterLoggingLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterLoggingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterLoggingHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterLoggingLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterLoggingLifecycle)
}

type ClusterLoggingLifecycle 

type ClusterLoggingLifecycle interface {
	Create(obj *ClusterLogging) (runtime.Object, error)
	Remove(obj *ClusterLogging) (runtime.Object, error)
	Updated(obj *ClusterLogging) (runtime.Object, error)
}

type ClusterLoggingList 

type ClusterLoggingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterLogging `json:"items"`
}

func (*ClusterLoggingList) DeepCopy 

func (in *ClusterLoggingList) DeepCopy() *ClusterLoggingList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterLoggingList.

func (*ClusterLoggingList) DeepCopyInto 

func (in *ClusterLoggingList) DeepCopyInto(out *ClusterLoggingList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterLoggingList) DeepCopyObject 

func (in *ClusterLoggingList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterLoggingLister 

type ClusterLoggingLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterLogging, err error)
	Get(namespace, name string) (*ClusterLogging, error)
}

type ClusterLoggingSpec 

type ClusterLoggingSpec struct {
	LoggingTargets
	LoggingCommonField
	ClusterName            string `json:"clusterName" norman:"type=reference[cluster]"`
	IncludeSystemComponent *bool  `json:"includeSystemComponent,omitempty" norman:"default=true"`
}

func (*ClusterLoggingSpec) DeepCopy 

func (in *ClusterLoggingSpec) DeepCopy() *ClusterLoggingSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterLoggingSpec.

func (*ClusterLoggingSpec) DeepCopyInto 

func (in *ClusterLoggingSpec) DeepCopyInto(out *ClusterLoggingSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterLoggingSpec) ObjClusterName 

func (c *ClusterLoggingSpec) ObjClusterName() string

type ClusterLoggingStatus 

type ClusterLoggingStatus struct {
	Conditions  []LoggingCondition  `json:"conditions,omitempty"`
	AppliedSpec ClusterLoggingSpec  `json:"appliedSpec,omitempty"`
	FailedSpec  *ClusterLoggingSpec `json:"failedSpec,omitempty"`
}

func (*ClusterLoggingStatus) DeepCopy 

func (in *ClusterLoggingStatus) DeepCopy() *ClusterLoggingStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterLoggingStatus.

func (*ClusterLoggingStatus) DeepCopyInto 

func (in *ClusterLoggingStatus) DeepCopyInto(out *ClusterLoggingStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterLoggingsGetter 

type ClusterLoggingsGetter interface {
	ClusterLoggings(namespace string) ClusterLoggingInterface
}

type ClusterMetricNamesInput 

type ClusterMetricNamesInput struct {
	ClusterName string `json:"clusterId" norman:"type=reference[cluster]"`
}

func (*ClusterMetricNamesInput) DeepCopy 

func (in *ClusterMetricNamesInput) DeepCopy() *ClusterMetricNamesInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterMetricNamesInput.

func (*ClusterMetricNamesInput) DeepCopyInto 

func (in *ClusterMetricNamesInput) DeepCopyInto(out *ClusterMetricNamesInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterMetricNamesInput) ObjClusterName 

func (c *ClusterMetricNamesInput) ObjClusterName() string

type ClusterMonitorGraph 

type ClusterMonitorGraph struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ClusterMonitorGraphSpec `json:"spec"`
}

func NewClusterMonitorGraph 

func NewClusterMonitorGraph(namespace, name string, obj ClusterMonitorGraph) *ClusterMonitorGraph

func (*ClusterMonitorGraph) DeepCopy 

func (in *ClusterMonitorGraph) DeepCopy() *ClusterMonitorGraph

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterMonitorGraph.

func (*ClusterMonitorGraph) DeepCopyInto 

func (in *ClusterMonitorGraph) DeepCopyInto(out *ClusterMonitorGraph)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterMonitorGraph) DeepCopyObject 

func (in *ClusterMonitorGraph) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterMonitorGraph) ObjClusterName 

func (c *ClusterMonitorGraph) ObjClusterName() string

type ClusterMonitorGraphChangeHandlerFunc 

type ClusterMonitorGraphChangeHandlerFunc func(obj *ClusterMonitorGraph) (runtime.Object, error)

type ClusterMonitorGraphController 

type ClusterMonitorGraphController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterMonitorGraphLister
	AddHandler(ctx context.Context, name string, handler ClusterMonitorGraphHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterMonitorGraphHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterMonitorGraphHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterMonitorGraphHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterMonitorGraphHandlerFunc 

type ClusterMonitorGraphHandlerFunc func(key string, obj *ClusterMonitorGraph) (runtime.Object, error)

func NewClusterMonitorGraphLifecycleAdapter 

func NewClusterMonitorGraphLifecycleAdapter(name string, clusterScoped bool, client ClusterMonitorGraphInterface, l ClusterMonitorGraphLifecycle) ClusterMonitorGraphHandlerFunc

type ClusterMonitorGraphInterface 

type ClusterMonitorGraphInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterMonitorGraph) (*ClusterMonitorGraph, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterMonitorGraph, error)
	Get(name string, opts metav1.GetOptions) (*ClusterMonitorGraph, error)
	Update(*ClusterMonitorGraph) (*ClusterMonitorGraph, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterMonitorGraphList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterMonitorGraphList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterMonitorGraphController
	AddHandler(ctx context.Context, name string, sync ClusterMonitorGraphHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterMonitorGraphHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterMonitorGraphLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterMonitorGraphLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterMonitorGraphHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterMonitorGraphHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterMonitorGraphLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterMonitorGraphLifecycle)
}

type ClusterMonitorGraphLifecycle 

type ClusterMonitorGraphLifecycle interface {
	Create(obj *ClusterMonitorGraph) (runtime.Object, error)
	Remove(obj *ClusterMonitorGraph) (runtime.Object, error)
	Updated(obj *ClusterMonitorGraph) (runtime.Object, error)
}

type ClusterMonitorGraphList 

type ClusterMonitorGraphList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterMonitorGraph `json:"items"`
}

func (*ClusterMonitorGraphList) DeepCopy 

func (in *ClusterMonitorGraphList) DeepCopy() *ClusterMonitorGraphList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterMonitorGraphList.

func (*ClusterMonitorGraphList) DeepCopyInto 

func (in *ClusterMonitorGraphList) DeepCopyInto(out *ClusterMonitorGraphList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterMonitorGraphList) DeepCopyObject 

func (in *ClusterMonitorGraphList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterMonitorGraphLister 

type ClusterMonitorGraphLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterMonitorGraph, err error)
	Get(namespace, name string) (*ClusterMonitorGraph, error)
}

type ClusterMonitorGraphSpec 

type ClusterMonitorGraphSpec struct {
	ClusterName         string `json:"clusterName" norman:"type=reference[cluster]"`
	ResourceType        string `` /* 147-byte string literal not displayed */
	DisplayResourceType string `json:"displayResourceType,omitempty" norman:"type=enum,options=node|cluster|etcd|kube-component|rancher-component"`
	CommonMonitorGraphSpec
}

func (*ClusterMonitorGraphSpec) DeepCopy 

func (in *ClusterMonitorGraphSpec) DeepCopy() *ClusterMonitorGraphSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterMonitorGraphSpec.

func (*ClusterMonitorGraphSpec) DeepCopyInto 

func (in *ClusterMonitorGraphSpec) DeepCopyInto(out *ClusterMonitorGraphSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterMonitorGraphSpec) ObjClusterName 

func (c *ClusterMonitorGraphSpec) ObjClusterName() string

type ClusterMonitorGraphsGetter 

type ClusterMonitorGraphsGetter interface {
	ClusterMonitorGraphs(namespace string) ClusterMonitorGraphInterface
}

type ClusterRegistrationToken 

type ClusterRegistrationToken struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec ClusterRegistrationTokenSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status ClusterRegistrationTokenStatus `json:"status"`
}

func NewClusterRegistrationToken 

func NewClusterRegistrationToken(namespace, name string, obj ClusterRegistrationToken) *ClusterRegistrationToken

func (*ClusterRegistrationToken) DeepCopy 

func (in *ClusterRegistrationToken) DeepCopy() *ClusterRegistrationToken

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterRegistrationToken.

func (*ClusterRegistrationToken) DeepCopyInto 

func (in *ClusterRegistrationToken) DeepCopyInto(out *ClusterRegistrationToken)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterRegistrationToken) DeepCopyObject 

func (in *ClusterRegistrationToken) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterRegistrationToken) ObjClusterName 

func (c *ClusterRegistrationToken) ObjClusterName() string

type ClusterRegistrationTokenChangeHandlerFunc 

type ClusterRegistrationTokenChangeHandlerFunc func(obj *ClusterRegistrationToken) (runtime.Object, error)

type ClusterRegistrationTokenController 

type ClusterRegistrationTokenController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterRegistrationTokenLister
	AddHandler(ctx context.Context, name string, handler ClusterRegistrationTokenHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterRegistrationTokenHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterRegistrationTokenHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterRegistrationTokenHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterRegistrationTokenHandlerFunc 

type ClusterRegistrationTokenHandlerFunc func(key string, obj *ClusterRegistrationToken) (runtime.Object, error)

func NewClusterRegistrationTokenLifecycleAdapter 

func NewClusterRegistrationTokenLifecycleAdapter(name string, clusterScoped bool, client ClusterRegistrationTokenInterface, l ClusterRegistrationTokenLifecycle) ClusterRegistrationTokenHandlerFunc

type ClusterRegistrationTokenInterface 

type ClusterRegistrationTokenInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterRegistrationToken) (*ClusterRegistrationToken, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterRegistrationToken, error)
	Get(name string, opts metav1.GetOptions) (*ClusterRegistrationToken, error)
	Update(*ClusterRegistrationToken) (*ClusterRegistrationToken, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterRegistrationTokenList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterRegistrationTokenList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterRegistrationTokenController
	AddHandler(ctx context.Context, name string, sync ClusterRegistrationTokenHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterRegistrationTokenHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterRegistrationTokenLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterRegistrationTokenLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRegistrationTokenHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterRegistrationTokenHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRegistrationTokenLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterRegistrationTokenLifecycle)
}

type ClusterRegistrationTokenLifecycle 

type ClusterRegistrationTokenLifecycle interface {
	Create(obj *ClusterRegistrationToken) (runtime.Object, error)
	Remove(obj *ClusterRegistrationToken) (runtime.Object, error)
	Updated(obj *ClusterRegistrationToken) (runtime.Object, error)
}

type ClusterRegistrationTokenList 

type ClusterRegistrationTokenList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterRegistrationToken `json:"items"`
}

func (*ClusterRegistrationTokenList) DeepCopy 

func (in *ClusterRegistrationTokenList) DeepCopy() *ClusterRegistrationTokenList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterRegistrationTokenList.

func (*ClusterRegistrationTokenList) DeepCopyInto 

func (in *ClusterRegistrationTokenList) DeepCopyInto(out *ClusterRegistrationTokenList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterRegistrationTokenList) DeepCopyObject 

func (in *ClusterRegistrationTokenList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterRegistrationTokenLister 

type ClusterRegistrationTokenLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterRegistrationToken, err error)
	Get(namespace, name string) (*ClusterRegistrationToken, error)
}

type ClusterRegistrationTokenSpec 

type ClusterRegistrationTokenSpec struct {
	ClusterName string `json:"clusterName" norman:"required,type=reference[cluster]"`
}

func (*ClusterRegistrationTokenSpec) DeepCopy 

func (in *ClusterRegistrationTokenSpec) DeepCopy() *ClusterRegistrationTokenSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterRegistrationTokenSpec.

func (*ClusterRegistrationTokenSpec) DeepCopyInto 

func (in *ClusterRegistrationTokenSpec) DeepCopyInto(out *ClusterRegistrationTokenSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterRegistrationTokenSpec) ObjClusterName 

func (c *ClusterRegistrationTokenSpec) ObjClusterName() string

type ClusterRegistrationTokenStatus 

type ClusterRegistrationTokenStatus struct {
	InsecureCommand    string `json:"insecureCommand"`
	Command            string `json:"command"`
	WindowsNodeCommand string `json:"windowsNodeCommand"`
	NodeCommand        string `json:"nodeCommand"`
	ManifestURL        string `json:"manifestUrl"`
	Token              string `json:"token"`
}

func (*ClusterRegistrationTokenStatus) DeepCopy 

func (in *ClusterRegistrationTokenStatus) DeepCopy() *ClusterRegistrationTokenStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterRegistrationTokenStatus.

func (*ClusterRegistrationTokenStatus) DeepCopyInto 

func (in *ClusterRegistrationTokenStatus) DeepCopyInto(out *ClusterRegistrationTokenStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterRegistrationTokensGetter 

type ClusterRegistrationTokensGetter interface {
	ClusterRegistrationTokens(namespace string) ClusterRegistrationTokenInterface
}

type ClusterRoleTemplateBinding 

type ClusterRoleTemplateBinding struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	UserName           string `json:"userName,omitempty" norman:"noupdate,type=reference[user]"`
	UserPrincipalName  string `json:"userPrincipalName,omitempty" norman:"noupdate,type=reference[principal]"`
	GroupName          string `json:"groupName,omitempty" norman:"noupdate,type=reference[group]"`
	GroupPrincipalName string `json:"groupPrincipalName,omitempty" norman:"noupdate,type=reference[principal]"`
	ClusterName        string `json:"clusterName,omitempty" norman:"required,noupdate,type=reference[cluster]"`
	RoleTemplateName   string `json:"roleTemplateName,omitempty" norman:"required,type=reference[roleTemplate]"`
}

func NewClusterRoleTemplateBinding 

func NewClusterRoleTemplateBinding(namespace, name string, obj ClusterRoleTemplateBinding) *ClusterRoleTemplateBinding

func (*ClusterRoleTemplateBinding) DeepCopy 

func (in *ClusterRoleTemplateBinding) DeepCopy() *ClusterRoleTemplateBinding

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterRoleTemplateBinding.

func (*ClusterRoleTemplateBinding) DeepCopyInto 

func (in *ClusterRoleTemplateBinding) DeepCopyInto(out *ClusterRoleTemplateBinding)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterRoleTemplateBinding) DeepCopyObject 

func (in *ClusterRoleTemplateBinding) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterRoleTemplateBinding) ObjClusterName 

func (c *ClusterRoleTemplateBinding) ObjClusterName() string

type ClusterRoleTemplateBindingChangeHandlerFunc 

type ClusterRoleTemplateBindingChangeHandlerFunc func(obj *ClusterRoleTemplateBinding) (runtime.Object, error)

type ClusterRoleTemplateBindingController 

type ClusterRoleTemplateBindingController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterRoleTemplateBindingLister
	AddHandler(ctx context.Context, name string, handler ClusterRoleTemplateBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterRoleTemplateBindingHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterRoleTemplateBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterRoleTemplateBindingHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterRoleTemplateBindingHandlerFunc 

type ClusterRoleTemplateBindingHandlerFunc func(key string, obj *ClusterRoleTemplateBinding) (runtime.Object, error)

func NewClusterRoleTemplateBindingLifecycleAdapter 

func NewClusterRoleTemplateBindingLifecycleAdapter(name string, clusterScoped bool, client ClusterRoleTemplateBindingInterface, l ClusterRoleTemplateBindingLifecycle) ClusterRoleTemplateBindingHandlerFunc

type ClusterRoleTemplateBindingInterface 

type ClusterRoleTemplateBindingInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterRoleTemplateBinding, error)
	Get(name string, opts metav1.GetOptions) (*ClusterRoleTemplateBinding, error)
	Update(*ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterRoleTemplateBindingList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterRoleTemplateBindingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterRoleTemplateBindingController
	AddHandler(ctx context.Context, name string, sync ClusterRoleTemplateBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterRoleTemplateBindingHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterRoleTemplateBindingLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterRoleTemplateBindingLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRoleTemplateBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterRoleTemplateBindingHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRoleTemplateBindingLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterRoleTemplateBindingLifecycle)
}

type ClusterRoleTemplateBindingLifecycle 

type ClusterRoleTemplateBindingLifecycle interface {
	Create(obj *ClusterRoleTemplateBinding) (runtime.Object, error)
	Remove(obj *ClusterRoleTemplateBinding) (runtime.Object, error)
	Updated(obj *ClusterRoleTemplateBinding) (runtime.Object, error)
}

type ClusterRoleTemplateBindingList 

type ClusterRoleTemplateBindingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterRoleTemplateBinding `json:"items"`
}

func (*ClusterRoleTemplateBindingList) DeepCopy 

func (in *ClusterRoleTemplateBindingList) DeepCopy() *ClusterRoleTemplateBindingList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterRoleTemplateBindingList.

func (*ClusterRoleTemplateBindingList) DeepCopyInto 

func (in *ClusterRoleTemplateBindingList) DeepCopyInto(out *ClusterRoleTemplateBindingList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterRoleTemplateBindingList) DeepCopyObject 

func (in *ClusterRoleTemplateBindingList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterRoleTemplateBindingLister 

type ClusterRoleTemplateBindingLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterRoleTemplateBinding, err error)
	Get(namespace, name string) (*ClusterRoleTemplateBinding, error)
}

type ClusterRoleTemplateBindingsGetter 

type ClusterRoleTemplateBindingsGetter interface {
	ClusterRoleTemplateBindings(namespace string) ClusterRoleTemplateBindingInterface
}

type ClusterScan 

type ClusterScan struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ClusterScanSpec   `json:"spec"`
	Status ClusterScanStatus `yaml:"status" json:"status,omitempty"`
}

func NewClusterScan 

func NewClusterScan(namespace, name string, obj ClusterScan) *ClusterScan

func (*ClusterScan) DeepCopy 

func (in *ClusterScan) DeepCopy() *ClusterScan

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterScan.

func (*ClusterScan) DeepCopyInto 

func (in *ClusterScan) DeepCopyInto(out *ClusterScan)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterScan) DeepCopyObject 

func (in *ClusterScan) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterScanChangeHandlerFunc 

type ClusterScanChangeHandlerFunc func(obj *ClusterScan) (runtime.Object, error)

type ClusterScanCondition 

type ClusterScanCondition struct {
	// Type of condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*ClusterScanCondition) DeepCopy 

func (in *ClusterScanCondition) DeepCopy() *ClusterScanCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterScanCondition.

func (*ClusterScanCondition) DeepCopyInto 

func (in *ClusterScanCondition) DeepCopyInto(out *ClusterScanCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterScanConfig 

type ClusterScanConfig struct {
	CisScanConfig *CisScanConfig `json:"cisScanConfig"`
}

func (*ClusterScanConfig) DeepCopy 

func (in *ClusterScanConfig) DeepCopy() *ClusterScanConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterScanConfig.

func (*ClusterScanConfig) DeepCopyInto 

func (in *ClusterScanConfig) DeepCopyInto(out *ClusterScanConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterScanController 

type ClusterScanController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterScanLister
	AddHandler(ctx context.Context, name string, handler ClusterScanHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterScanHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterScanHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterScanHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterScanHandlerFunc 

type ClusterScanHandlerFunc func(key string, obj *ClusterScan) (runtime.Object, error)

func NewClusterScanLifecycleAdapter 

func NewClusterScanLifecycleAdapter(name string, clusterScoped bool, client ClusterScanInterface, l ClusterScanLifecycle) ClusterScanHandlerFunc

type ClusterScanInterface 

type ClusterScanInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterScan) (*ClusterScan, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterScan, error)
	Get(name string, opts metav1.GetOptions) (*ClusterScan, error)
	Update(*ClusterScan) (*ClusterScan, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterScanList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterScanList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterScanController
	AddHandler(ctx context.Context, name string, sync ClusterScanHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterScanHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterScanLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterScanLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterScanHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterScanHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterScanLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterScanLifecycle)
}

type ClusterScanLifecycle 

type ClusterScanLifecycle interface {
	Create(obj *ClusterScan) (runtime.Object, error)
	Remove(obj *ClusterScan) (runtime.Object, error)
	Updated(obj *ClusterScan) (runtime.Object, error)
}

type ClusterScanList 

type ClusterScanList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterScan `json:"items"`
}

func (*ClusterScanList) DeepCopy 

func (in *ClusterScanList) DeepCopy() *ClusterScanList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterScanList.

func (*ClusterScanList) DeepCopyInto 

func (in *ClusterScanList) DeepCopyInto(out *ClusterScanList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterScanList) DeepCopyObject 

func (in *ClusterScanList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterScanLister 

type ClusterScanLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterScan, err error)
	Get(namespace, name string) (*ClusterScan, error)
}

type ClusterScanRule 

type ClusterScanRule struct {
	ScanRunType  ClusterScanRunType `json:"scanRunType,omitempty" norman:"required,options=manual|scheduled,default=scheduled"`
	FailuresOnly bool               `json:"failuresOnly,omitempty"`
}

func (*ClusterScanRule) DeepCopy 

func (in *ClusterScanRule) DeepCopy() *ClusterScanRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterScanRule.

func (*ClusterScanRule) DeepCopyInto 

func (in *ClusterScanRule) DeepCopyInto(out *ClusterScanRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterScanRunType 

type ClusterScanRunType string

type ClusterScanSpec 

type ClusterScanSpec struct {
	ScanType string `json:"scanType"`
	// cluster ID
	ClusterID string `json:"clusterId,omitempty" norman:"required,type=reference[cluster]"`
	// Run type
	RunType ClusterScanRunType `json:"runType,omitempty"`
	// scanConfig
	ScanConfig ClusterScanConfig `yaml:",omitempty" json:"scanConfig,omitempty"`
}

func (*ClusterScanSpec) DeepCopy 

func (in *ClusterScanSpec) DeepCopy() *ClusterScanSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterScanSpec.

func (*ClusterScanSpec) DeepCopyInto 

func (in *ClusterScanSpec) DeepCopyInto(out *ClusterScanSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterScanStatus 

type ClusterScanStatus struct {
	Conditions    []ClusterScanCondition `json:"conditions"`
	CisScanStatus *CisScanStatus         `json:"cisScanStatus"`
}

func (*ClusterScanStatus) DeepCopy 

func (in *ClusterScanStatus) DeepCopy() *ClusterScanStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterScanStatus.

func (*ClusterScanStatus) DeepCopyInto 

func (in *ClusterScanStatus) DeepCopyInto(out *ClusterScanStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterScansGetter 

type ClusterScansGetter interface {
	ClusterScans(namespace string) ClusterScanInterface
}

type ClusterSpec 

type ClusterSpec struct {
	ClusterSpecBase
	DisplayName                         string              `json:"displayName" norman:"required"`
	Description                         string              `json:"description"`
	Internal                            bool                `json:"internal" norman:"nocreate,noupdate"`
	K3sConfig                           *K3sConfig          `json:"k3sConfig,omitempty"`
	ImportedConfig                      *ImportedConfig     `json:"importedConfig,omitempty" norman:"nocreate,noupdate"`
	GoogleKubernetesEngineConfig        *MapStringInterface `json:"googleKubernetesEngineConfig,omitempty"`
	AzureKubernetesServiceConfig        *MapStringInterface `json:"azureKubernetesServiceConfig,omitempty"`
	AmazonElasticContainerServiceConfig *MapStringInterface `json:"amazonElasticContainerServiceConfig,omitempty"`
	GenericEngineConfig                 *MapStringInterface `json:"genericEngineConfig,omitempty"`
	ClusterTemplateName                 string              `json:"clusterTemplateName,omitempty" norman:"type=reference[clusterTemplate],nocreate,noupdate"`
	ClusterTemplateRevisionName         string              `json:"clusterTemplateRevisionName,omitempty" norman:"type=reference[clusterTemplateRevision]"`
	ClusterTemplateAnswers              Answer              `json:"answers,omitempty"`
	ClusterTemplateQuestions            []Question          `json:"questions,omitempty" norman:"nocreate,noupdate"`
}

func (*ClusterSpec) DeepCopy 

func (in *ClusterSpec) DeepCopy() *ClusterSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterSpec.

func (*ClusterSpec) DeepCopyInto 

func (in *ClusterSpec) DeepCopyInto(out *ClusterSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterSpecBase 

type ClusterSpecBase struct {
	DesiredAgentImage                    string                         `json:"desiredAgentImage"`
	DesiredAuthImage                     string                         `json:"desiredAuthImage"`
	AgentImageOverride                   string                         `json:"agentImageOverride"`
	RancherKubernetesEngineConfig        *RancherKubernetesEngineConfig `json:"rancherKubernetesEngineConfig,omitempty"`
	DefaultPodSecurityPolicyTemplateName string                         `json:"defaultPodSecurityPolicyTemplateName,omitempty" norman:"type=reference[podSecurityPolicyTemplate]"`
	DefaultClusterRoleForProjectMembers  string                         `json:"defaultClusterRoleForProjectMembers,omitempty" norman:"type=reference[roleTemplate]"`
	DockerRootDir                        string                         `json:"dockerRootDir,omitempty" norman:"default=/var/lib/docker"`
	EnableNetworkPolicy                  *bool                          `json:"enableNetworkPolicy" norman:"default=false"`
	EnableClusterAlerting                bool                           `json:"enableClusterAlerting" norman:"default=false"`
	EnableClusterMonitoring              bool                           `json:"enableClusterMonitoring" norman:"default=false"`
	WindowsPreferedCluster               bool                           `json:"windowsPreferedCluster" norman:"noupdate"`
	LocalClusterAuthEndpoint             LocalClusterAuthEndpoint       `json:"localClusterAuthEndpoint,omitempty"`
	ScheduledClusterScan                 *ScheduledClusterScan          `json:"scheduledClusterScan,omitempty"`
}

func (*ClusterSpecBase) DeepCopy 

func (in *ClusterSpecBase) DeepCopy() *ClusterSpecBase

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterSpecBase.

func (*ClusterSpecBase) DeepCopyInto 

func (in *ClusterSpecBase) DeepCopyInto(out *ClusterSpecBase)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterStatus 

type ClusterStatus struct {
	// Conditions represent the latest available observations of an object's current state:
	// More info: https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#typical-status-properties
	Conditions []ClusterCondition `json:"conditions,omitempty"`
	// Component statuses will represent cluster's components (etcd/controller/scheduler) health
	// https://kubernetes.io/docs/api-reference/v1.8/#componentstatus-v1-core
	Driver                               string                      `json:"driver"`
	AgentImage                           string                      `json:"agentImage"`
	AgentFeatures                        map[string]bool             `json:"agentFeatures,omitempty"`
	AuthImage                            string                      `json:"authImage"`
	ComponentStatuses                    []ClusterComponentStatus    `json:"componentStatuses,omitempty"`
	APIEndpoint                          string                      `json:"apiEndpoint,omitempty"`
	ServiceAccountToken                  string                      `json:"serviceAccountToken,omitempty"`
	CACert                               string                      `json:"caCert,omitempty"`
	Capacity                             v1.ResourceList             `json:"capacity,omitempty"`
	Allocatable                          v1.ResourceList             `json:"allocatable,omitempty"`
	AppliedSpec                          ClusterSpec                 `json:"appliedSpec,omitempty"`
	FailedSpec                           *ClusterSpec                `json:"failedSpec,omitempty"`
	Requested                            v1.ResourceList             `json:"requested,omitempty"`
	Limits                               v1.ResourceList             `json:"limits,omitempty"`
	Version                              *version.Info               `json:"version,omitempty"`
	AppliedPodSecurityPolicyTemplateName string                      `json:"appliedPodSecurityPolicyTemplateId"`
	AppliedEnableNetworkPolicy           bool                        `json:"appliedEnableNetworkPolicy" norman:"nocreate,noupdate,default=false"`
	Capabilities                         Capabilities                `json:"capabilities,omitempty"`
	MonitoringStatus                     *MonitoringStatus           `json:"monitoringStatus,omitempty" norman:"nocreate,noupdate"`
	NodeVersion                          int                         `json:"nodeVersion,omitempty"`
	NodeCount                            int                         `json:"nodeCount,omitempty" norman:"nocreate,noupdate"`
	IstioEnabled                         bool                        `json:"istioEnabled,omitempty" norman:"nocreate,noupdate,default=false"`
	CertificatesExpiration               map[string]CertExpiration   `json:"certificatesExpiration,omitempty"`
	ScheduledClusterScanStatus           *ScheduledClusterScanStatus `json:"scheduledClusterScanStatus,omitempty"`
	CurrentCisRunName                    string                      `json:"currentCisRunName,omitempty"`
	PrivateRegistrySecret                string                      `json:"privateRegistrySecret,omitempty" norman:"nocreate,noupdate"`
	S3CredentialSecret                   string                      `json:"s3CredentialSecret,omitempty" norman:"nocreate,noupdate"`
	WeavePasswordSecret                  string                      `json:"weavePasswordSecret,omitempty" norman:"nocreate,noupdate"`
	VsphereSecret                        string                      `json:"vsphereSecret,omitempty" norman:"nocreate,noupdate"`
	VirtualCenterSecret                  string                      `json:"virtualCenterSecret,omitempty" norman:"nocreate,noupdate"`
	OpenStackSecret                      string                      `json:"openStackSecret,omitempty" norman:"nocreate,noupdate"`
	AADClientSecret                      string                      `json:"aadClientSecret,omitempty" norman:"nocreate,noupdate"`
	AADClientCertSecret                  string                      `json:"aadClientCertSecret,omitempty" norman:"nocreate,noupdate"`
}

func (*ClusterStatus) DeepCopy 

func (in *ClusterStatus) DeepCopy() *ClusterStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterStatus.

func (*ClusterStatus) DeepCopyInto 

func (in *ClusterStatus) DeepCopyInto(out *ClusterStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterTemplate 

type ClusterTemplate struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ClusterTemplateSpec `json:"spec"`
}

func NewClusterTemplate 

func NewClusterTemplate(namespace, name string, obj ClusterTemplate) *ClusterTemplate

func (*ClusterTemplate) DeepCopy 

func (in *ClusterTemplate) DeepCopy() *ClusterTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplate.

func (*ClusterTemplate) DeepCopyInto 

func (in *ClusterTemplate) DeepCopyInto(out *ClusterTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterTemplate) DeepCopyObject 

func (in *ClusterTemplate) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterTemplateChangeHandlerFunc 

type ClusterTemplateChangeHandlerFunc func(obj *ClusterTemplate) (runtime.Object, error)

type ClusterTemplateController 

type ClusterTemplateController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterTemplateLister
	AddHandler(ctx context.Context, name string, handler ClusterTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterTemplateHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterTemplateHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterTemplateHandlerFunc 

type ClusterTemplateHandlerFunc func(key string, obj *ClusterTemplate) (runtime.Object, error)

func NewClusterTemplateLifecycleAdapter 

func NewClusterTemplateLifecycleAdapter(name string, clusterScoped bool, client ClusterTemplateInterface, l ClusterTemplateLifecycle) ClusterTemplateHandlerFunc

type ClusterTemplateInterface 

type ClusterTemplateInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterTemplate) (*ClusterTemplate, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterTemplate, error)
	Get(name string, opts metav1.GetOptions) (*ClusterTemplate, error)
	Update(*ClusterTemplate) (*ClusterTemplate, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterTemplateList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterTemplateController
	AddHandler(ctx context.Context, name string, sync ClusterTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterTemplateHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterTemplateLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterTemplateLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterTemplateHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterTemplateLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterTemplateLifecycle)
}

type ClusterTemplateLifecycle 

type ClusterTemplateLifecycle interface {
	Create(obj *ClusterTemplate) (runtime.Object, error)
	Remove(obj *ClusterTemplate) (runtime.Object, error)
	Updated(obj *ClusterTemplate) (runtime.Object, error)
}

type ClusterTemplateList 

type ClusterTemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterTemplate `json:"items"`
}

func (*ClusterTemplateList) DeepCopy 

func (in *ClusterTemplateList) DeepCopy() *ClusterTemplateList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateList.

func (*ClusterTemplateList) DeepCopyInto 

func (in *ClusterTemplateList) DeepCopyInto(out *ClusterTemplateList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterTemplateList) DeepCopyObject 

func (in *ClusterTemplateList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterTemplateLister 

type ClusterTemplateLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterTemplate, err error)
	Get(namespace, name string) (*ClusterTemplate, error)
}

type ClusterTemplateQuestionsOutput 

type ClusterTemplateQuestionsOutput struct {
	Questions []Question `json:"questions,omitempty"`
}

func (*ClusterTemplateQuestionsOutput) DeepCopy 

func (in *ClusterTemplateQuestionsOutput) DeepCopy() *ClusterTemplateQuestionsOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateQuestionsOutput.

func (*ClusterTemplateQuestionsOutput) DeepCopyInto 

func (in *ClusterTemplateQuestionsOutput) DeepCopyInto(out *ClusterTemplateQuestionsOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterTemplateRevision 

type ClusterTemplateRevision struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec   ClusterTemplateRevisionSpec   `json:"spec"`
	Status ClusterTemplateRevisionStatus `json:"status"`
}

func NewClusterTemplateRevision 

func NewClusterTemplateRevision(namespace, name string, obj ClusterTemplateRevision) *ClusterTemplateRevision

func (*ClusterTemplateRevision) DeepCopy 

func (in *ClusterTemplateRevision) DeepCopy() *ClusterTemplateRevision

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateRevision.

func (*ClusterTemplateRevision) DeepCopyInto 

func (in *ClusterTemplateRevision) DeepCopyInto(out *ClusterTemplateRevision)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterTemplateRevision) DeepCopyObject 

func (in *ClusterTemplateRevision) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterTemplateRevisionChangeHandlerFunc 

type ClusterTemplateRevisionChangeHandlerFunc func(obj *ClusterTemplateRevision) (runtime.Object, error)

type ClusterTemplateRevisionCondition 

type ClusterTemplateRevisionCondition struct {
	// Type of cluster template revision condition.
	Type ClusterTemplateRevisionConditionType `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*ClusterTemplateRevisionCondition) DeepCopy 

func (in *ClusterTemplateRevisionCondition) DeepCopy() *ClusterTemplateRevisionCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateRevisionCondition.

func (*ClusterTemplateRevisionCondition) DeepCopyInto 

func (in *ClusterTemplateRevisionCondition) DeepCopyInto(out *ClusterTemplateRevisionCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterTemplateRevisionConditionType 

type ClusterTemplateRevisionConditionType string

type ClusterTemplateRevisionController 

type ClusterTemplateRevisionController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterTemplateRevisionLister
	AddHandler(ctx context.Context, name string, handler ClusterTemplateRevisionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterTemplateRevisionHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterTemplateRevisionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterTemplateRevisionHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterTemplateRevisionHandlerFunc 

type ClusterTemplateRevisionHandlerFunc func(key string, obj *ClusterTemplateRevision) (runtime.Object, error)

func NewClusterTemplateRevisionLifecycleAdapter 

func NewClusterTemplateRevisionLifecycleAdapter(name string, clusterScoped bool, client ClusterTemplateRevisionInterface, l ClusterTemplateRevisionLifecycle) ClusterTemplateRevisionHandlerFunc

type ClusterTemplateRevisionInterface 

type ClusterTemplateRevisionInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ClusterTemplateRevision) (*ClusterTemplateRevision, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterTemplateRevision, error)
	Get(name string, opts metav1.GetOptions) (*ClusterTemplateRevision, error)
	Update(*ClusterTemplateRevision) (*ClusterTemplateRevision, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ClusterTemplateRevisionList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterTemplateRevisionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ClusterTemplateRevisionController
	AddHandler(ctx context.Context, name string, sync ClusterTemplateRevisionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterTemplateRevisionHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ClusterTemplateRevisionLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ClusterTemplateRevisionLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterTemplateRevisionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ClusterTemplateRevisionHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterTemplateRevisionLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ClusterTemplateRevisionLifecycle)
}

type ClusterTemplateRevisionLifecycle 

type ClusterTemplateRevisionLifecycle interface {
	Create(obj *ClusterTemplateRevision) (runtime.Object, error)
	Remove(obj *ClusterTemplateRevision) (runtime.Object, error)
	Updated(obj *ClusterTemplateRevision) (runtime.Object, error)
}

type ClusterTemplateRevisionList 

type ClusterTemplateRevisionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterTemplateRevision `json:"items"`
}

func (*ClusterTemplateRevisionList) DeepCopy 

func (in *ClusterTemplateRevisionList) DeepCopy() *ClusterTemplateRevisionList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateRevisionList.

func (*ClusterTemplateRevisionList) DeepCopyInto 

func (in *ClusterTemplateRevisionList) DeepCopyInto(out *ClusterTemplateRevisionList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterTemplateRevisionList) DeepCopyObject 

func (in *ClusterTemplateRevisionList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ClusterTemplateRevisionLister 

type ClusterTemplateRevisionLister interface {
	List(namespace string, selector labels.Selector) (ret []*ClusterTemplateRevision, err error)
	Get(namespace, name string) (*ClusterTemplateRevision, error)
}

type ClusterTemplateRevisionSpec 

type ClusterTemplateRevisionSpec struct {
	DisplayName         string `json:"displayName" norman:"required"`
	Enabled             *bool  `json:"enabled,omitempty" norman:"default=true"`
	ClusterTemplateName string `json:"clusterTemplateName,omitempty" norman:"type=reference[clusterTemplate],required,noupdate"`

	Questions     []Question       `json:"questions,omitempty"`
	ClusterConfig *ClusterSpecBase `json:"clusterConfig" norman:"required"`
}

func (*ClusterTemplateRevisionSpec) DeepCopy 

func (in *ClusterTemplateRevisionSpec) DeepCopy() *ClusterTemplateRevisionSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateRevisionSpec.

func (*ClusterTemplateRevisionSpec) DeepCopyInto 

func (in *ClusterTemplateRevisionSpec) DeepCopyInto(out *ClusterTemplateRevisionSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterTemplateRevisionStatus 

type ClusterTemplateRevisionStatus struct {
	PrivateRegistrySecret string                             `json:"privateRegistrySecret,omitempty" norman:"nocreate,noupdate"`
	S3CredentialSecret    string                             `json:"s3CredentialSecret,omitempty" norman:"nocreate,noupdate"`
	WeavePasswordSecret   string                             `json:"weavePasswordSecret,omitempty" norman:"nocreate,noupdate"`
	VsphereSecret         string                             `json:"vsphereSecret,omitempty" norman:"nocreate,noupdate"`
	VirtualCenterSecret   string                             `json:"virtualCenterSecret,omitempty" norman:"nocreate,noupdate"`
	OpenStackSecret       string                             `json:"openStackSecret,omitempty" norman:"nocreate,noupdate"`
	AADClientSecret       string                             `json:"aadClientSecret,omitempty" norman:"nocreate,noupdate"`
	AADClientCertSecret   string                             `json:"aadClientCertSecret,omitempty" norman:"nocreate,noupdate"`
	Conditions            []ClusterTemplateRevisionCondition `json:"conditions,omitempty"`
}

func (*ClusterTemplateRevisionStatus) DeepCopy 

func (in *ClusterTemplateRevisionStatus) DeepCopy() *ClusterTemplateRevisionStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateRevisionStatus.

func (*ClusterTemplateRevisionStatus) DeepCopyInto 

func (in *ClusterTemplateRevisionStatus) DeepCopyInto(out *ClusterTemplateRevisionStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterTemplateRevisionsGetter 

type ClusterTemplateRevisionsGetter interface {
	ClusterTemplateRevisions(namespace string) ClusterTemplateRevisionInterface
}

type ClusterTemplateSpec 

type ClusterTemplateSpec struct {
	DisplayName         string `json:"displayName" norman:"required"`
	Description         string `json:"description"`
	DefaultRevisionName string `json:"defaultRevisionName,omitempty" norman:"type=reference[clusterTemplateRevision]"`

	Members []Member `json:"members,omitempty"`
}

func (*ClusterTemplateSpec) DeepCopy 

func (in *ClusterTemplateSpec) DeepCopy() *ClusterTemplateSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTemplateSpec.

func (*ClusterTemplateSpec) DeepCopyInto 

func (in *ClusterTemplateSpec) DeepCopyInto(out *ClusterTemplateSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterTemplatesGetter 

type ClusterTemplatesGetter interface {
	ClusterTemplates(namespace string) ClusterTemplateInterface
}

type ClusterTestInput 

type ClusterTestInput struct {
	ClusterName string `json:"clusterId" norman:"required,type=reference[cluster]"`
	LoggingTargets
	OutputTags map[string]string `json:"outputTags,omitempty"`
}

func (*ClusterTestInput) DeepCopy 

func (in *ClusterTestInput) DeepCopy() *ClusterTestInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTestInput.

func (*ClusterTestInput) DeepCopyInto 

func (in *ClusterTestInput) DeepCopyInto(out *ClusterTestInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterTestInput) ObjClusterName 

func (c *ClusterTestInput) ObjClusterName() string

type ClustersGetter 

type ClustersGetter interface {
	Clusters(namespace string) ClusterInterface
}

type CommonGroupField 

type CommonGroupField struct {
	DisplayName string `json:"displayName,omitempty" norman:"required"`
	Description string `json:"description,omitempty"`
	TimingField
}

func (*CommonGroupField) DeepCopy 

func (in *CommonGroupField) DeepCopy() *CommonGroupField

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CommonGroupField.

func (*CommonGroupField) DeepCopyInto 

func (in *CommonGroupField) DeepCopyInto(out *CommonGroupField)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CommonMonitorGraphSpec 

type CommonMonitorGraphSpec struct {
	Description            string            `json:"description,omitempty"`
	MetricsSelector        map[string]string `json:"metricsSelector,omitempty"`
	DetailsMetricsSelector map[string]string `json:"detailsMetricsSelector,omitempty"`
	YAxis                  YAxis             `json:"yAxis,omitempty"`
	Priority               int               `json:"priority,omitempty"`
	GraphType              string            `json:"graphType,omitempty" norman:"type=enum,options=graph|singlestat"`
}

func (*CommonMonitorGraphSpec) DeepCopy 

func (in *CommonMonitorGraphSpec) DeepCopy() *CommonMonitorGraphSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CommonMonitorGraphSpec.

func (*CommonMonitorGraphSpec) DeepCopyInto 

func (in *CommonMonitorGraphSpec) DeepCopyInto(out *CommonMonitorGraphSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CommonQueryMetricInput 

type CommonQueryMetricInput struct {
	From     string `json:"from,omitempty"`
	To       string `json:"to,omitempty"`
	Interval string `json:"interval,omitempty"`
	Expr     string `json:"expr,omitempty" norman:"required"`
}

func (*CommonQueryMetricInput) DeepCopy 

func (in *CommonQueryMetricInput) DeepCopy() *CommonQueryMetricInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CommonQueryMetricInput.

func (*CommonQueryMetricInput) DeepCopyInto 

func (in *CommonQueryMetricInput) DeepCopyInto(out *CommonQueryMetricInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CommonRuleField 

type CommonRuleField struct {
	DisplayName string `json:"displayName,omitempty"`
	Severity    string `json:"severity,omitempty" norman:"required,options=info|critical|warning,default=critical"`
	Inherited   *bool  `json:"inherited,omitempty" norman:"default=true"`
	TimingField
}

func (*CommonRuleField) DeepCopy 

func (in *CommonRuleField) DeepCopy() *CommonRuleField

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CommonRuleField.

func (*CommonRuleField) DeepCopyInto 

func (in *CommonRuleField) DeepCopyInto(out *CommonRuleField)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ComposeCondition 

type ComposeCondition struct {
	// Type of cluster condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*ComposeCondition) DeepCopy 

func (in *ComposeCondition) DeepCopy() *ComposeCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeCondition.

func (*ComposeCondition) DeepCopyInto 

func (in *ComposeCondition) DeepCopyInto(out *ComposeCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ComposeConfig 

type ComposeConfig struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec   ComposeSpec   `json:"spec,omitempty"`
	Status ComposeStatus `json:"status,omitempty"`
}

func NewComposeConfig 

func NewComposeConfig(namespace, name string, obj ComposeConfig) *ComposeConfig

func (*ComposeConfig) DeepCopy 

func (in *ComposeConfig) DeepCopy() *ComposeConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeConfig.

func (*ComposeConfig) DeepCopyInto 

func (in *ComposeConfig) DeepCopyInto(out *ComposeConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ComposeConfig) DeepCopyObject 

func (in *ComposeConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ComposeConfigChangeHandlerFunc 

type ComposeConfigChangeHandlerFunc func(obj *ComposeConfig) (runtime.Object, error)

type ComposeConfigController 

type ComposeConfigController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ComposeConfigLister
	AddHandler(ctx context.Context, name string, handler ComposeConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ComposeConfigHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ComposeConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ComposeConfigHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ComposeConfigHandlerFunc 

type ComposeConfigHandlerFunc func(key string, obj *ComposeConfig) (runtime.Object, error)

func NewComposeConfigLifecycleAdapter 

func NewComposeConfigLifecycleAdapter(name string, clusterScoped bool, client ComposeConfigInterface, l ComposeConfigLifecycle) ComposeConfigHandlerFunc

type ComposeConfigInterface 

type ComposeConfigInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ComposeConfig) (*ComposeConfig, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ComposeConfig, error)
	Get(name string, opts metav1.GetOptions) (*ComposeConfig, error)
	Update(*ComposeConfig) (*ComposeConfig, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ComposeConfigList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ComposeConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ComposeConfigController
	AddHandler(ctx context.Context, name string, sync ComposeConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ComposeConfigHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ComposeConfigLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ComposeConfigLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ComposeConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ComposeConfigHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ComposeConfigLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ComposeConfigLifecycle)
}

type ComposeConfigLifecycle 

type ComposeConfigLifecycle interface {
	Create(obj *ComposeConfig) (runtime.Object, error)
	Remove(obj *ComposeConfig) (runtime.Object, error)
	Updated(obj *ComposeConfig) (runtime.Object, error)
}

type ComposeConfigList 

type ComposeConfigList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ComposeConfig `json:"items"`
}

func (*ComposeConfigList) DeepCopy 

func (in *ComposeConfigList) DeepCopy() *ComposeConfigList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeConfigList.

func (*ComposeConfigList) DeepCopyInto 

func (in *ComposeConfigList) DeepCopyInto(out *ComposeConfigList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ComposeConfigList) DeepCopyObject 

func (in *ComposeConfigList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ComposeConfigLister 

type ComposeConfigLister interface {
	List(namespace string, selector labels.Selector) (ret []*ComposeConfig, err error)
	Get(namespace, name string) (*ComposeConfig, error)
}

type ComposeConfigsGetter 

type ComposeConfigsGetter interface {
	ComposeConfigs(namespace string) ComposeConfigInterface
}

type ComposeSpec 

type ComposeSpec struct {
	RancherCompose string `json:"rancherCompose,omitempty"`
}

func (*ComposeSpec) DeepCopy 

func (in *ComposeSpec) DeepCopy() *ComposeSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeSpec.

func (*ComposeSpec) DeepCopyInto 

func (in *ComposeSpec) DeepCopyInto(out *ComposeSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ComposeStatus 

type ComposeStatus struct {
	Conditions []ComposeCondition `json:"conditions,omitempty"`
}

func (*ComposeStatus) DeepCopy 

func (in *ComposeStatus) DeepCopy() *ComposeStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeStatus.

func (*ComposeStatus) DeepCopyInto 

func (in *ComposeStatus) DeepCopyInto(out *ComposeStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Condition 

type Condition struct {
	// Type of cluster condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*Condition) DeepCopy 

func (in *Condition) DeepCopy() *Condition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Condition.

func (*Condition) DeepCopyInto 

func (in *Condition) DeepCopyInto(out *Condition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Configuration 

type Configuration struct {
	metav1.TypeMeta `json:",inline"`

	// limits are the limits to place on event queries received.
	// Limits can be placed on events received server-wide, per namespace,
	// per user, and per source+object.
	// At least one limit is required.
	Limits []Limit `json:"limits"`
}

Configuration provides configuration for the EventRateLimit admission controller.

func (*Configuration) DeepCopy 

func (in *Configuration) DeepCopy() *Configuration

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Configuration.

func (*Configuration) DeepCopyInto 

func (in *Configuration) DeepCopyInto(out *Configuration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Configuration) DeepCopyObject 

func (in *Configuration) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ContainerResourceLimit 

type ContainerResourceLimit struct {
	RequestsCPU    string `json:"requestsCpu,omitempty"`
	RequestsMemory string `json:"requestsMemory,omitempty"`
	LimitsCPU      string `json:"limitsCpu,omitempty"`
	LimitsMemory   string `json:"limitsMemory,omitempty"`
}

func (*ContainerResourceLimit) DeepCopy 

func (in *ContainerResourceLimit) DeepCopy() *ContainerResourceLimit

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerResourceLimit.

func (*ContainerResourceLimit) DeepCopyInto 

func (in *ContainerResourceLimit) DeepCopyInto(out *ContainerResourceLimit)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CustomConfig 

type CustomConfig struct {
	// IP or FQDN that is fully resolvable and used for SSH communication
	Address string `yaml:"address" json:"address,omitempty"`
	// Optional - Internal address that will be used for components communication
	InternalAddress string `yaml:"internal_address" json:"internalAddress,omitempty"`
	// SSH user that will be used by RKE
	User string `yaml:"user" json:"user,omitempty"`
	// Optional - Docker socket on the node that will be used in tunneling
	DockerSocket string `yaml:"docker_socket" json:"dockerSocket,omitempty"`
	// SSH Private Key
	SSHKey string `yaml:"ssh_key" json:"sshKey,omitempty" norman:"type=password"`
	// SSH Certificate
	SSHCert string            `yaml:"ssh_cert" json:"sshCert,omitempty"`
	Label   map[string]string `yaml:"label" json:"label,omitempty"`
	Taints  []string          `yaml:"taints" json:"taints,omitempty"`
}

func (*CustomConfig) DeepCopy 

func (in *CustomConfig) DeepCopy() *CustomConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CustomConfig.

func (*CustomConfig) DeepCopyInto 

func (in *CustomConfig) DeepCopyInto(out *CustomConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CustomTargetConfig 

type CustomTargetConfig struct {
	Content     string `json:"content,omitempty"`
	Certificate string `json:"certificate,omitempty"`
	ClientCert  string `json:"clientCert,omitempty"`
	ClientKey   string `json:"clientKey,omitempty"`
}

func (*CustomTargetConfig) DeepCopy 

func (in *CustomTargetConfig) DeepCopy() *CustomTargetConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CustomTargetConfig.

func (*CustomTargetConfig) DeepCopyInto 

func (in *CustomTargetConfig) DeepCopyInto(out *CustomTargetConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DNSConfig 

type DNSConfig struct {
	// DNS provider
	Provider string `yaml:"provider" json:"provider,omitempty"`
	// Upstream nameservers
	UpstreamNameservers []string `yaml:"upstreamnameservers" json:"upstreamnameservers,omitempty"`
	// ReverseCIDRs
	ReverseCIDRs []string `yaml:"reversecidrs" json:"reversecidrs,omitempty"`
	// Stubdomains
	StubDomains map[string][]string `yaml:"stubdomains" json:"stubdomains,omitempty"`
	// NodeSelector key pair
	NodeSelector map[string]string `yaml:"node_selector" json:"nodeSelector,omitempty"`
	// Nodelocal DNS
	Nodelocal *Nodelocal `yaml:"nodelocal" json:"nodelocal,omitempy"`
	// Update strategy
	UpdateStrategy *DeploymentStrategy `yaml:"update_strategy" json:"updateStrategy,omitempty"`
	// Autoscaler fields to determine number of dns replicas
	LinearAutoscalerParams *LinearAutoscalerParams `yaml:"linear_autoscaler_params" json:"linearAutoscalerParams,omitempty"`
	// Tolerations for Deployments
	Tolerations []v1.Toleration `yaml:"tolerations" json:"tolerations,omitempty"`
}

func (*DNSConfig) DeepCopy 

func (in *DNSConfig) DeepCopy() *DNSConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DNSConfig.

func (*DNSConfig) DeepCopyInto 

func (in *DNSConfig) DeepCopyInto(out *DNSConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DaemonSetUpdateStrategy 

type DaemonSetUpdateStrategy struct {
	// Type of daemon set update. Can be "RollingUpdate" or "OnDelete". Default is RollingUpdate.
	// +optional
	Strategy appsv1.DaemonSetUpdateStrategyType `json:"strategy,omitempty" protobuf:"bytes,1,opt,name=type"`

	// Rolling update config params. Present only if type = "RollingUpdate".
	//---
	// TODO: Update this to follow our convention for oneOf, whatever we decide it
	// to be. Same as Deployment `strategy.rollingUpdate`.
	// See https://github.com/kubernetes/kubernetes/issues/35345
	// +optional
	RollingUpdate *appsv1.RollingUpdateDaemonSet `json:"rollingUpdate,omitempty" protobuf:"bytes,2,opt,name=rollingUpdate"`
}

DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet.

func (*DaemonSetUpdateStrategy) DeepCopy 

func (in *DaemonSetUpdateStrategy) DeepCopy() *DaemonSetUpdateStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSetUpdateStrategy.

func (*DaemonSetUpdateStrategy) DeepCopyInto 

func (in *DaemonSetUpdateStrategy) DeepCopyInto(out *DaemonSetUpdateStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DeploymentStrategy 

type DeploymentStrategy struct {
	// Type of deployment. Can be "Recreate" or "RollingUpdate". Default is RollingUpdate.
	// +optional
	Strategy appsv1.DeploymentStrategyType `json:"strategy,omitempty" protobuf:"bytes,1,opt,name=type,casttype=DeploymentStrategyType"`

	// Rolling update config params. Present only if DeploymentStrategyType =
	// RollingUpdate.
	//---
	// TODO: Update this to follow our convention for oneOf, whatever we decide it
	// to be.
	// +optional
	RollingUpdate *appsv1.RollingUpdateDeployment `json:"rollingUpdate,omitempty" protobuf:"bytes,2,opt,name=rollingUpdate"`
}

DeploymentStrategy describes how to replace existing pods with new ones.

func (*DeploymentStrategy) DeepCopy 

func (in *DeploymentStrategy) DeepCopy() *DeploymentStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentStrategy.

func (*DeploymentStrategy) DeepCopyInto 

func (in *DeploymentStrategy) DeepCopyInto(out *DeploymentStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DingtalkConfig 

type DingtalkConfig struct {
	URL    string `json:"url,omitempty" norman:"required"`
	Secret string `json:"secret,omitempty" norman:"type=password"`
	*HTTPClientConfig
}

func (*DingtalkConfig) DeepCopy 

func (in *DingtalkConfig) DeepCopy() *DingtalkConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DingtalkConfig.

func (*DingtalkConfig) DeepCopyInto 

func (in *DingtalkConfig) DeepCopyInto(out *DingtalkConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DiskVsphereOpts 

type DiskVsphereOpts struct {
	SCSIControllerType string `json:"scsicontrollertype,omitempty" yaml:"scsicontrollertype,omitempty" ini:"scsicontrollertype,omitempty"`
}

func (*DiskVsphereOpts) DeepCopy 

func (in *DiskVsphereOpts) DeepCopy() *DiskVsphereOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DiskVsphereOpts.

func (*DiskVsphereOpts) DeepCopyInto 

func (in *DiskVsphereOpts) DeepCopyInto(out *DiskVsphereOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DockerInfo 

type DockerInfo struct {
	ID                 string
	Driver             string
	Debug              bool
	LoggingDriver      string
	CgroupDriver       string
	KernelVersion      string
	OperatingSystem    string
	OSType             string
	Architecture       string
	IndexServerAddress string
	InitBinary         string
	DockerRootDir      string
	SecurityOptions    []string
	HTTPProxy          string
	HTTPSProxy         string
	NoProxy            string
	Name               string
	Labels             []string
	ExperimentalBuild  bool
	ServerVersion      string
}

func (*DockerInfo) DeepCopy 

func (in *DockerInfo) DeepCopy() *DockerInfo

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DockerInfo.

func (*DockerInfo) DeepCopyInto 

func (in *DockerInfo) DeepCopyInto(out *DockerInfo)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DynamicSchema 

type DynamicSchema struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec DynamicSchemaSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status DynamicSchemaStatus `json:"status"`
}

func NewDynamicSchema 

func NewDynamicSchema(namespace, name string, obj DynamicSchema) *DynamicSchema

func (*DynamicSchema) DeepCopy 

func (in *DynamicSchema) DeepCopy() *DynamicSchema

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DynamicSchema.

func (*DynamicSchema) DeepCopyInto 

func (in *DynamicSchema) DeepCopyInto(out *DynamicSchema)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*DynamicSchema) DeepCopyObject 

func (in *DynamicSchema) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type DynamicSchemaChangeHandlerFunc 

type DynamicSchemaChangeHandlerFunc func(obj *DynamicSchema) (runtime.Object, error)

type DynamicSchemaController 

type DynamicSchemaController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() DynamicSchemaLister
	AddHandler(ctx context.Context, name string, handler DynamicSchemaHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync DynamicSchemaHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler DynamicSchemaHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler DynamicSchemaHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type DynamicSchemaHandlerFunc 

type DynamicSchemaHandlerFunc func(key string, obj *DynamicSchema) (runtime.Object, error)

func NewDynamicSchemaLifecycleAdapter 

func NewDynamicSchemaLifecycleAdapter(name string, clusterScoped bool, client DynamicSchemaInterface, l DynamicSchemaLifecycle) DynamicSchemaHandlerFunc

type DynamicSchemaInterface 

type DynamicSchemaInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*DynamicSchema) (*DynamicSchema, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*DynamicSchema, error)
	Get(name string, opts metav1.GetOptions) (*DynamicSchema, error)
	Update(*DynamicSchema) (*DynamicSchema, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*DynamicSchemaList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*DynamicSchemaList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() DynamicSchemaController
	AddHandler(ctx context.Context, name string, sync DynamicSchemaHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync DynamicSchemaHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle DynamicSchemaLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle DynamicSchemaLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DynamicSchemaHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync DynamicSchemaHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DynamicSchemaLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle DynamicSchemaLifecycle)
}

type DynamicSchemaLifecycle 

type DynamicSchemaLifecycle interface {
	Create(obj *DynamicSchema) (runtime.Object, error)
	Remove(obj *DynamicSchema) (runtime.Object, error)
	Updated(obj *DynamicSchema) (runtime.Object, error)
}

type DynamicSchemaList 

type DynamicSchemaList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []DynamicSchema `json:"items"`
}

func (*DynamicSchemaList) DeepCopy 

func (in *DynamicSchemaList) DeepCopy() *DynamicSchemaList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DynamicSchemaList.

func (*DynamicSchemaList) DeepCopyInto 

func (in *DynamicSchemaList) DeepCopyInto(out *DynamicSchemaList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*DynamicSchemaList) DeepCopyObject 

func (in *DynamicSchemaList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type DynamicSchemaLister 

type DynamicSchemaLister interface {
	List(namespace string, selector labels.Selector) (ret []*DynamicSchema, err error)
	Get(namespace, name string) (*DynamicSchema, error)
}

type DynamicSchemaSpec 

type DynamicSchemaSpec struct {
	SchemaName           string            `json:"schemaName,omitempty"`
	Embed                bool              `json:"embed,omitempty"`
	EmbedType            string            `json:"embedType,omitempty"`
	PluralName           string            `json:"pluralName,omitempty"`
	ResourceMethods      []string          `json:"resourceMethods,omitempty"`
	ResourceFields       map[string]Field  `json:"resourceFields,omitempty"`
	ResourceActions      map[string]Action `json:"resourceActions,omitempty"`
	CollectionMethods    []string          `json:"collectionMethods,omitempty"`
	CollectionFields     map[string]Field  `json:"collectionFields,omitempty"`
	CollectionActions    map[string]Action `json:"collectionActions,omitempty"`
	CollectionFilters    map[string]Filter `json:"collectionFilters,omitempty"`
	IncludeableLinks     []string          `json:"includeableLinks,omitempty"`
	DynamicSchemaVersion string            `json:"dynamicSchemaVersion,omitempty"`
}

func (*DynamicSchemaSpec) DeepCopy 

func (in *DynamicSchemaSpec) DeepCopy() *DynamicSchemaSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DynamicSchemaSpec.

func (*DynamicSchemaSpec) DeepCopyInto 

func (in *DynamicSchemaSpec) DeepCopyInto(out *DynamicSchemaSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DynamicSchemaStatus 

type DynamicSchemaStatus struct {
	Fake string `json:"fake,omitempty"`
}

func (*DynamicSchemaStatus) DeepCopy 

func (in *DynamicSchemaStatus) DeepCopy() *DynamicSchemaStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DynamicSchemaStatus.

func (*DynamicSchemaStatus) DeepCopyInto 

func (in *DynamicSchemaStatus) DeepCopyInto(out *DynamicSchemaStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type DynamicSchemasGetter 

type DynamicSchemasGetter interface {
	DynamicSchemas(namespace string) DynamicSchemaInterface
}

type ETCDService 

type ETCDService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
	// List of etcd urls
	ExternalURLs []string `yaml:"external_urls" json:"externalUrls,omitempty"`
	// External CA certificate
	CACert string `yaml:"ca_cert" json:"caCert,omitempty"`
	// External Client certificate
	Cert string `yaml:"cert" json:"cert,omitempty"`
	// External Client key
	Key string `yaml:"key" json:"key,omitempty"`
	// External etcd prefix
	Path string `yaml:"path" json:"path,omitempty"`
	// UID to run etcd container as
	UID int `yaml:"uid" json:"uid,omitempty"`
	// GID to run etcd container as
	GID int `yaml:"gid" json:"gid,omitempty"`

	// Etcd Recurring snapshot Service, used by rke only
	Snapshot *bool `yaml:"snapshot" json:"snapshot,omitempty" norman:"default=false"`
	// Etcd snapshot Retention period
	Retention string `yaml:"retention" json:"retention,omitempty" norman:"default=72h"`
	// Etcd snapshot Creation period
	Creation string `yaml:"creation" json:"creation,omitempty" norman:"default=12h"`
	// Backup backend for etcd snapshots
	BackupConfig *BackupConfig `yaml:"backup_config" json:"backupConfig,omitempty"`
}

func (*ETCDService) DeepCopy 

func (in *ETCDService) DeepCopy() *ETCDService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ETCDService.

func (*ETCDService) DeepCopyInto 

func (in *ETCDService) DeepCopyInto(out *ETCDService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ElasticsearchConfig 

type ElasticsearchConfig struct {
	Endpoint      string `json:"endpoint,omitempty" norman:"required"`
	IndexPrefix   string `json:"indexPrefix,omitempty" norman:"required"`
	DateFormat    string `json:"dateFormat,omitempty" norman:"required,type=enum,options=YYYY-MM-DD|YYYY-MM|YYYY,default=YYYY-MM-DD"`
	AuthUserName  string `json:"authUsername,omitempty"`
	AuthPassword  string `json:"authPassword,omitempty" norman:"type=password"`
	Certificate   string `json:"certificate,omitempty"`
	ClientCert    string `json:"clientCert,omitempty"`
	ClientKey     string `json:"clientKey,omitempty"`
	ClientKeyPass string `json:"clientKeyPass,omitempty"`
	SSLVerify     bool   `json:"sslVerify,omitempty"`
	SSLVersion    string `json:"sslVersion,omitempty" norman:"type=enum,options=SSLv23|TLSv1|TLSv1_1|TLSv1_2,default=TLSv1_2"`
}

func (*ElasticsearchConfig) DeepCopy 

func (in *ElasticsearchConfig) DeepCopy() *ElasticsearchConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ElasticsearchConfig.

func (*ElasticsearchConfig) DeepCopyInto 

func (in *ElasticsearchConfig) DeepCopyInto(out *ElasticsearchConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type EtcdBackup 

type EtcdBackup struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// backup spec
	Spec EtcdBackupSpec `json:"spec"`
	// backup status
	Status EtcdBackupStatus `yaml:"status" json:"status,omitempty"`
}

func NewEtcdBackup 

func NewEtcdBackup(namespace, name string, obj EtcdBackup) *EtcdBackup

func (*EtcdBackup) DeepCopy 

func (in *EtcdBackup) DeepCopy() *EtcdBackup

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EtcdBackup.

func (*EtcdBackup) DeepCopyInto 

func (in *EtcdBackup) DeepCopyInto(out *EtcdBackup)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*EtcdBackup) DeepCopyObject 

func (in *EtcdBackup) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type EtcdBackupChangeHandlerFunc 

type EtcdBackupChangeHandlerFunc func(obj *EtcdBackup) (runtime.Object, error)

type EtcdBackupCondition 

type EtcdBackupCondition struct {
	// Type of condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*EtcdBackupCondition) DeepCopy 

func (in *EtcdBackupCondition) DeepCopy() *EtcdBackupCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EtcdBackupCondition.

func (*EtcdBackupCondition) DeepCopyInto 

func (in *EtcdBackupCondition) DeepCopyInto(out *EtcdBackupCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type EtcdBackupController 

type EtcdBackupController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() EtcdBackupLister
	AddHandler(ctx context.Context, name string, handler EtcdBackupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync EtcdBackupHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler EtcdBackupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler EtcdBackupHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type EtcdBackupHandlerFunc 

type EtcdBackupHandlerFunc func(key string, obj *EtcdBackup) (runtime.Object, error)

func NewEtcdBackupLifecycleAdapter 

func NewEtcdBackupLifecycleAdapter(name string, clusterScoped bool, client EtcdBackupInterface, l EtcdBackupLifecycle) EtcdBackupHandlerFunc

type EtcdBackupInterface 

type EtcdBackupInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*EtcdBackup) (*EtcdBackup, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*EtcdBackup, error)
	Get(name string, opts metav1.GetOptions) (*EtcdBackup, error)
	Update(*EtcdBackup) (*EtcdBackup, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*EtcdBackupList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*EtcdBackupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() EtcdBackupController
	AddHandler(ctx context.Context, name string, sync EtcdBackupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync EtcdBackupHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle EtcdBackupLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle EtcdBackupLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync EtcdBackupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync EtcdBackupHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle EtcdBackupLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle EtcdBackupLifecycle)
}

type EtcdBackupLifecycle 

type EtcdBackupLifecycle interface {
	Create(obj *EtcdBackup) (runtime.Object, error)
	Remove(obj *EtcdBackup) (runtime.Object, error)
	Updated(obj *EtcdBackup) (runtime.Object, error)
}

type EtcdBackupList 

type EtcdBackupList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []EtcdBackup `json:"items"`
}

func (*EtcdBackupList) DeepCopy 

func (in *EtcdBackupList) DeepCopy() *EtcdBackupList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EtcdBackupList.

func (*EtcdBackupList) DeepCopyInto 

func (in *EtcdBackupList) DeepCopyInto(out *EtcdBackupList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*EtcdBackupList) DeepCopyObject 

func (in *EtcdBackupList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type EtcdBackupLister 

type EtcdBackupLister interface {
	List(namespace string, selector labels.Selector) (ret []*EtcdBackup, err error)
	Get(namespace, name string) (*EtcdBackup, error)
}

type EtcdBackupSpec 

type EtcdBackupSpec struct {
	// cluster ID
	ClusterID string `json:"clusterId,omitempty" norman:"required,type=reference[cluster],noupdate"`
	// manual backup flag
	Manual bool `yaml:"manual" json:"manual,omitempty"`
	// actual file name on the target
	Filename string `yaml:"filename" json:"filename,omitempty" norman:"noupdate"`
	// backupConfig
	BackupConfig BackupConfig `yaml:",omitempty" json:"backupConfig,omitempty" norman:"noupdate"`
}

func (*EtcdBackupSpec) DeepCopy 

func (in *EtcdBackupSpec) DeepCopy() *EtcdBackupSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EtcdBackupSpec.

func (*EtcdBackupSpec) DeepCopyInto 

func (in *EtcdBackupSpec) DeepCopyInto(out *EtcdBackupSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type EtcdBackupStatus 

type EtcdBackupStatus struct {
	Conditions []EtcdBackupCondition `json:"conditions"`
	// version of k8s in the backup pulled from rke config
	KubernetesVersion string `yaml:"kubernetesVersion" json:"kubernetesVersion,omitempty" norman:"noupdate"`
	// json + gzipped + base64 backup of the cluster object when the backup was created
	ClusterObject string `yaml:"clusterObject" json:"clusterObject,omitempty" norman:"type=password,noupdate"`
}

func (*EtcdBackupStatus) DeepCopy 

func (in *EtcdBackupStatus) DeepCopy() *EtcdBackupStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EtcdBackupStatus.

func (*EtcdBackupStatus) DeepCopyInto 

func (in *EtcdBackupStatus) DeepCopyInto(out *EtcdBackupStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type EtcdBackupsGetter 

type EtcdBackupsGetter interface {
	EtcdBackups(namespace string) EtcdBackupInterface
}

type EventRateLimit 

type EventRateLimit struct {
	Enabled       bool           `yaml:"enabled" json:"enabled,omitempty"`
	Configuration *Configuration `yaml:"configuration" json:"configuration,omitempty" norman:"type=map[json]"`
}

func (*EventRateLimit) DeepCopy 

func (in *EventRateLimit) DeepCopy() *EventRateLimit

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EventRateLimit.

func (*EventRateLimit) DeepCopyInto 

func (in *EventRateLimit) DeepCopyInto(out *EventRateLimit)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type EventRule 

type EventRule struct {
	EventType    string `json:"eventType,omitempty" norman:"required,options=Normal|Warning,default=Warning"`
	ResourceKind string `json:"resourceKind,omitempty" norman:"required,options=Pod|Node|Deployment|StatefulSet|DaemonSet"`
}

func (*EventRule) DeepCopy 

func (in *EventRule) DeepCopy() *EventRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EventRule.

func (*EventRule) DeepCopyInto 

func (in *EventRule) DeepCopyInto(out *EventRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ExportOutput 

type ExportOutput struct {
	YAMLOutput string `json:"yamlOutput"`
}

func (*ExportOutput) DeepCopy 

func (in *ExportOutput) DeepCopy() *ExportOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExportOutput.

func (*ExportOutput) DeepCopyInto 

func (in *ExportOutput) DeepCopyInto(out *ExportOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ExtraEnv 

type ExtraEnv struct {
	v1.EnvVar
}

func (*ExtraEnv) DeepCopy 

func (in *ExtraEnv) DeepCopy() *ExtraEnv

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtraEnv.

func (*ExtraEnv) DeepCopyInto 

func (in *ExtraEnv) DeepCopyInto(out *ExtraEnv)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ExtraVolume 

type ExtraVolume struct {
	v1.Volume
}

func (*ExtraVolume) DeepCopy 

func (in *ExtraVolume) DeepCopy() *ExtraVolume

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtraVolume.

func (*ExtraVolume) DeepCopyInto 

func (in *ExtraVolume) DeepCopyInto(out *ExtraVolume)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ExtraVolumeMount 

type ExtraVolumeMount struct {
	v1.VolumeMount
}

func (*ExtraVolumeMount) DeepCopy 

func (in *ExtraVolumeMount) DeepCopy() *ExtraVolumeMount

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtraVolumeMount.

func (*ExtraVolumeMount) DeepCopyInto 

func (in *ExtraVolumeMount) DeepCopyInto(out *ExtraVolumeMount)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Feature 

type Feature struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   FeatureSpec   `json:"spec"`
	Status FeatureStatus `json:"status"`
}

func NewFeature 

func NewFeature(namespace, name string, obj Feature) *Feature

func (*Feature) DeepCopy 

func (in *Feature) DeepCopy() *Feature

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Feature.

func (*Feature) DeepCopyInto 

func (in *Feature) DeepCopyInto(out *Feature)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Feature) DeepCopyObject 

func (in *Feature) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type FeatureChangeHandlerFunc 

type FeatureChangeHandlerFunc func(obj *Feature) (runtime.Object, error)

type FeatureController 

type FeatureController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() FeatureLister
	AddHandler(ctx context.Context, name string, handler FeatureHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync FeatureHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler FeatureHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler FeatureHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type FeatureHandlerFunc 

type FeatureHandlerFunc func(key string, obj *Feature) (runtime.Object, error)

func NewFeatureLifecycleAdapter 

func NewFeatureLifecycleAdapter(name string, clusterScoped bool, client FeatureInterface, l FeatureLifecycle) FeatureHandlerFunc

type FeatureInterface 

type FeatureInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Feature) (*Feature, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Feature, error)
	Get(name string, opts metav1.GetOptions) (*Feature, error)
	Update(*Feature) (*Feature, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*FeatureList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*FeatureList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() FeatureController
	AddHandler(ctx context.Context, name string, sync FeatureHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync FeatureHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle FeatureLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle FeatureLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync FeatureHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync FeatureHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle FeatureLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle FeatureLifecycle)
}

type FeatureLifecycle 

type FeatureLifecycle interface {
	Create(obj *Feature) (runtime.Object, error)
	Remove(obj *Feature) (runtime.Object, error)
	Updated(obj *Feature) (runtime.Object, error)
}

type FeatureList 

type FeatureList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Feature `json:"items"`
}

func (*FeatureList) DeepCopy 

func (in *FeatureList) DeepCopy() *FeatureList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FeatureList.

func (*FeatureList) DeepCopyInto 

func (in *FeatureList) DeepCopyInto(out *FeatureList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*FeatureList) DeepCopyObject 

func (in *FeatureList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type FeatureLister 

type FeatureLister interface {
	List(namespace string, selector labels.Selector) (ret []*Feature, err error)
	Get(namespace, name string) (*Feature, error)
}

type FeatureSpec 

type FeatureSpec struct {
	Value *bool `json:"value" norman:"required"`
}

func (*FeatureSpec) DeepCopy 

func (in *FeatureSpec) DeepCopy() *FeatureSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FeatureSpec.

func (*FeatureSpec) DeepCopyInto 

func (in *FeatureSpec) DeepCopyInto(out *FeatureSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FeatureStatus 

type FeatureStatus struct {
	Dynamic     bool   `json:"dynamic"`
	Default     bool   `json:"default"`
	Description string `json:"description"`
}

func (*FeatureStatus) DeepCopy 

func (in *FeatureStatus) DeepCopy() *FeatureStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FeatureStatus.

func (*FeatureStatus) DeepCopyInto 

func (in *FeatureStatus) DeepCopyInto(out *FeatureStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FeaturesGetter 

type FeaturesGetter interface {
	Features(namespace string) FeatureInterface
}

type Field 

type Field struct {
	Type         string   `json:"type,omitempty"`
	Default      Values   `json:"default,omitempty"`
	Unique       bool     `json:"unique,omitempty"`
	Nullable     bool     `json:"nullable,omitempty"`
	Create       bool     `json:"create,omitempty"`
	Required     bool     `json:"required,omitempty"`
	Update       bool     `json:"update,omitempty"`
	MinLength    int64    `json:"minLength,omitempty"`
	MaxLength    int64    `json:"maxLength,omitempty"`
	Min          int64    `json:"min,omitempty"`
	Max          int64    `json:"max,omitempty"`
	Options      []string `json:"options,omitempty"`
	ValidChars   string   `json:"validChars,omitempty"`
	InvalidChars string   `json:"invalidChars,omitempty"`
	Description  string   `json:"description,omitempty"`
	DynamicField bool     `json:"dynamicField,omitempty"`
}

func (*Field) DeepCopy 

func (in *Field) DeepCopy() *Field

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Field.

func (*Field) DeepCopyInto 

func (in *Field) DeepCopyInto(out *Field)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type File 

type File struct {
	Name     string `json:"name,omitempty"`
	Contents string `json:"contents,omitempty"`
}

func (*File) DeepCopy 

func (in *File) DeepCopy() *File

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new File.

func (*File) DeepCopyInto 

func (in *File) DeepCopyInto(out *File)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Filter 

type Filter struct {
	Modifiers []string `json:"modifiers,omitempty"`
}

func (*Filter) DeepCopy 

func (in *Filter) DeepCopy() *Filter

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Filter.

func (*Filter) DeepCopyInto 

func (in *Filter) DeepCopyInto(out *Filter)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FlannelNetworkProvider 

type FlannelNetworkProvider struct {
	// Alternate cloud interface for flannel
	Iface string `json:"iface"`
}

func (*FlannelNetworkProvider) DeepCopy 

func (in *FlannelNetworkProvider) DeepCopy() *FlannelNetworkProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlannelNetworkProvider.

func (*FlannelNetworkProvider) DeepCopyInto 

func (in *FlannelNetworkProvider) DeepCopyInto(out *FlannelNetworkProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FluentForwarderConfig 

type FluentForwarderConfig struct {
	EnableTLS     bool           `json:"enableTls,omitempty" norman:"default=false"`
	Certificate   string         `json:"certificate,omitempty"`
	ClientCert    string         `json:"clientCert,omitempty"`
	ClientKey     string         `json:"clientKey,omitempty"`
	ClientKeyPass string         `json:"clientKeyPass,omitempty"`
	SSLVerify     bool           `json:"sslVerify,omitempty"`
	Compress      *bool          `json:"compress,omitempty" norman:"default=true"`
	FluentServers []FluentServer `json:"fluentServers,omitempty" norman:"required"`
}

func (*FluentForwarderConfig) DeepCopy 

func (in *FluentForwarderConfig) DeepCopy() *FluentForwarderConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FluentForwarderConfig.

func (*FluentForwarderConfig) DeepCopyInto 

func (in *FluentForwarderConfig) DeepCopyInto(out *FluentForwarderConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FluentServer 

type FluentServer struct {
	Endpoint  string `json:"endpoint,omitempty" norman:"required"`
	Hostname  string `json:"hostname,omitempty"`
	Weight    int    `json:"weight,omitempty" norman:"default=100"`
	Standby   bool   `json:"standby,omitempty" norman:"default=false"`
	Username  string `json:"username,omitempty"`
	Password  string `json:"password,omitempty" norman:"type=password"`
	SharedKey string `json:"sharedKey,omitempty" norman:"type=password"`
}

func (*FluentServer) DeepCopy 

func (in *FluentServer) DeepCopy() *FluentServer

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FluentServer.

func (*FluentServer) DeepCopyInto 

func (in *FluentServer) DeepCopyInto(out *FluentServer)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FreeIpaConfig 

type FreeIpaConfig struct {
	LdapConfig `json:",inline" mapstructure:",squash"`
}

func (*FreeIpaConfig) DeepCopy 

func (in *FreeIpaConfig) DeepCopy() *FreeIpaConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FreeIpaConfig.

func (*FreeIpaConfig) DeepCopyInto 

func (in *FreeIpaConfig) DeepCopyInto(out *FreeIpaConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*FreeIpaConfig) DeepCopyObject 

func (in *FreeIpaConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type FreeIpaTestAndApplyInput 

type FreeIpaTestAndApplyInput struct {
	LdapTestAndApplyInput `json:",inline" mapstructure:",squash"`
}

func (*FreeIpaTestAndApplyInput) DeepCopy 

func (in *FreeIpaTestAndApplyInput) DeepCopy() *FreeIpaTestAndApplyInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FreeIpaTestAndApplyInput.

func (*FreeIpaTestAndApplyInput) DeepCopyInto 

func (in *FreeIpaTestAndApplyInput) DeepCopyInto(out *FreeIpaTestAndApplyInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*FreeIpaTestAndApplyInput) DeepCopyObject 

func (in *FreeIpaTestAndApplyInput) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GenerateKubeConfigOutput 

type GenerateKubeConfigOutput struct {
	Config string `json:"config"`
}

func (*GenerateKubeConfigOutput) DeepCopy 

func (in *GenerateKubeConfigOutput) DeepCopy() *GenerateKubeConfigOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GenerateKubeConfigOutput.

func (*GenerateKubeConfigOutput) DeepCopyInto 

func (in *GenerateKubeConfigOutput) DeepCopyInto(out *GenerateKubeConfigOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GithubConfig 

type GithubConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	AuthConfig        `json:",inline" mapstructure:",squash"`

	Hostname     string `json:"hostname,omitempty" norman:"default=github.com" norman:"required"`
	TLS          bool   `json:"tls,omitempty" norman:"notnullable,default=true" norman:"required"`
	ClientID     string `json:"clientId,omitempty" norman:"required"`
	ClientSecret string `json:"clientSecret,omitempty" norman:"required,type=password"`

	// AdditionalClientIDs is a map of clientID to client secrets
	AdditionalClientIDs map[string]string `json:"additionalClientIds,omitempty" norman:"nocreate,noupdate"`
	HostnameToClientID  map[string]string `json:"hostnameToClientId,omitempty" norman:"nocreate,noupdate"`
}

func (*GithubConfig) DeepCopy 

func (in *GithubConfig) DeepCopy() *GithubConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GithubConfig.

func (*GithubConfig) DeepCopyInto 

func (in *GithubConfig) DeepCopyInto(out *GithubConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GithubConfig) DeepCopyObject 

func (in *GithubConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GithubConfigApplyInput 

type GithubConfigApplyInput struct {
	GithubConfig GithubConfig `json:"githubConfig,omitempty"`
	Code         string       `json:"code,omitempty"`
	Enabled      bool         `json:"enabled,omitempty"`
}

func (*GithubConfigApplyInput) DeepCopy 

func (in *GithubConfigApplyInput) DeepCopy() *GithubConfigApplyInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GithubConfigApplyInput.

func (*GithubConfigApplyInput) DeepCopyInto 

func (in *GithubConfigApplyInput) DeepCopyInto(out *GithubConfigApplyInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GithubConfigTestOutput 

type GithubConfigTestOutput struct {
	RedirectURL string `json:"redirectUrl"`
}

func (*GithubConfigTestOutput) DeepCopy 

func (in *GithubConfigTestOutput) DeepCopy() *GithubConfigTestOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GithubConfigTestOutput.

func (*GithubConfigTestOutput) DeepCopyInto 

func (in *GithubConfigTestOutput) DeepCopyInto(out *GithubConfigTestOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GlobalAwsOpts 

type GlobalAwsOpts struct {
	// TODO: Is there any use for this?  We can get it from the instance metadata service
	// Maybe if we're not running on AWS, e.g. bootstrap; for now it is not very useful
	Zone string `json:"zone" yaml:"zone" ini:"Zone,omitempty"`

	// The AWS VPC flag enables the possibility to run the master components
	// on a different aws account, on a different cloud provider or on-premises.
	// If the flag is set also the KubernetesClusterTag must be provided
	VPC string `json:"vpc" yaml:"vpc" ini:"VPC,omitempty"`
	// SubnetID enables using a specific subnet to use for ELB's
	SubnetID string `json:"subnet-id" yaml:"subnet-id" ini:"SubnetID,omitempty"`
	// RouteTableID enables using a specific RouteTable
	RouteTableID string `json:"routetable-id" yaml:"routetable-id" ini:"RouteTableID,omitempty"`

	// RoleARN is the IAM role to assume when interaction with AWS APIs.
	RoleARN string `json:"role-arn" yaml:"role-arn" ini:"RoleARN,omitempty"`

	// KubernetesClusterTag is the legacy cluster id we'll use to identify our cluster resources
	KubernetesClusterTag string `json:"kubernetes-cluster-tag" yaml:"kubernetes-cluster-tag" ini:"KubernetesClusterTag,omitempty"`
	// KubernetesClusterID is the cluster id we'll use to identify our cluster resources
	KubernetesClusterID string `json:"kubernetes-cluster-id" yaml:"kubernetes-cluster-id" ini:"KubernetesClusterID,omitempty"`

	//The aws provider creates an inbound rule per load balancer on the node security
	//group. However, this can run into the AWS security group rule limit of 50 if
	//many LoadBalancers are created.
	//
	//This flag disables the automatic ingress creation. It requires that the user
	//has setup a rule that allows inbound traffic on kubelet ports from the
	//local VPC subnet (so load balancers can access it). E.g. 10.82.0.0/16 30000-32000.
	DisableSecurityGroupIngress bool `json:"disable-security-group-ingress" yaml:"disable-security-group-ingress" ini:"DisableSecurityGroupIngress,omitempty"`

	//AWS has a hard limit of 500 security groups. For large clusters creating a security group for each ELB
	//can cause the max number of security groups to be reached. If this is set instead of creating a new
	//Security group for each ELB this security group will be used instead.
	ElbSecurityGroup string `json:"elb-security-group" yaml:"elb-security-group" ini:"ElbSecurityGroup,omitempty"`

	//During the instantiation of an new AWS cloud provider, the detected region
	//is validated against a known set of regions.
	//
	//In a non-standard, AWS like environment (e.g. Eucalyptus), this check may
	//be undesirable.  Setting this to true will disable the check and provide
	//a warning that the check was skipped.  Please note that this is an
	//experimental feature and work-in-progress for the moment.  If you find
	//yourself in an non-AWS cloud and open an issue, please indicate that in the
	//issue body.
	DisableStrictZoneCheck bool `json:"disable-strict-zone-check" yaml:"disable-strict-zone-check" ini:"DisableStrictZoneCheck,omitempty"`
}

func (*GlobalAwsOpts) DeepCopy 

func (in *GlobalAwsOpts) DeepCopy() *GlobalAwsOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalAwsOpts.

func (*GlobalAwsOpts) DeepCopyInto 

func (in *GlobalAwsOpts) DeepCopyInto(out *GlobalAwsOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GlobalDNS 

type GlobalDNS struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   GlobalDNSSpec   `json:"spec,omitempty"`
	Status GlobalDNSStatus `json:"status,omitempty"`
}

func NewGlobalDNS 

func NewGlobalDNS(namespace, name string, obj GlobalDNS) *GlobalDNS

func (*GlobalDNS) DeepCopy 

func (in *GlobalDNS) DeepCopy() *GlobalDNS

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalDNS.

func (*GlobalDNS) DeepCopyInto 

func (in *GlobalDNS) DeepCopyInto(out *GlobalDNS)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalDNS) DeepCopyObject 

func (in *GlobalDNS) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalDNSChangeHandlerFunc 

type GlobalDNSChangeHandlerFunc func(obj *GlobalDNS) (runtime.Object, error)

type GlobalDNSController 

type GlobalDNSController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() GlobalDNSLister
	AddHandler(ctx context.Context, name string, handler GlobalDNSHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalDNSHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GlobalDNSHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler GlobalDNSHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type GlobalDNSHandlerFunc 

type GlobalDNSHandlerFunc func(key string, obj *GlobalDNS) (runtime.Object, error)

func NewGlobalDNSLifecycleAdapter 

func NewGlobalDNSLifecycleAdapter(name string, clusterScoped bool, client GlobalDNSInterface, l GlobalDNSLifecycle) GlobalDNSHandlerFunc

type GlobalDNSInterface 

type GlobalDNSInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*GlobalDNS) (*GlobalDNS, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*GlobalDNS, error)
	Get(name string, opts metav1.GetOptions) (*GlobalDNS, error)
	Update(*GlobalDNS) (*GlobalDNS, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*GlobalDNSList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*GlobalDNSList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() GlobalDNSController
	AddHandler(ctx context.Context, name string, sync GlobalDNSHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalDNSHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle GlobalDNSLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle GlobalDNSLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalDNSHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync GlobalDNSHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalDNSLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle GlobalDNSLifecycle)
}

type GlobalDNSLifecycle 

type GlobalDNSLifecycle interface {
	Create(obj *GlobalDNS) (runtime.Object, error)
	Remove(obj *GlobalDNS) (runtime.Object, error)
	Updated(obj *GlobalDNS) (runtime.Object, error)
}

type GlobalDNSList 

type GlobalDNSList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []GlobalDNS `json:"items"`
}

func (*GlobalDNSList) DeepCopy 

func (in *GlobalDNSList) DeepCopy() *GlobalDNSList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalDNSList.

func (*GlobalDNSList) DeepCopyInto 

func (in *GlobalDNSList) DeepCopyInto(out *GlobalDNSList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalDNSList) DeepCopyObject 

func (in *GlobalDNSList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalDNSLister 

type GlobalDNSLister interface {
	List(namespace string, selector labels.Selector) (ret []*GlobalDNS, err error)
	Get(namespace, name string) (*GlobalDNS, error)
}

type GlobalDNSProvider 

type GlobalDNSProvider struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	//ObjectMeta.Name = GlobalDNSProviderID
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec GlobalDNSProviderSpec `json:"spec,omitempty"`
}

func NewGlobalDNSProvider 

func NewGlobalDNSProvider(namespace, name string, obj GlobalDNSProvider) *GlobalDNSProvider

func (*GlobalDNSProvider) DeepCopy 

func (in *GlobalDNSProvider) DeepCopy() *GlobalDNSProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalDNSProvider.

func (*GlobalDNSProvider) DeepCopyInto 

func (in *GlobalDNSProvider) DeepCopyInto(out *GlobalDNSProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalDNSProvider) DeepCopyObject 

func (in *GlobalDNSProvider) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalDNSProviderChangeHandlerFunc 

type GlobalDNSProviderChangeHandlerFunc func(obj *GlobalDNSProvider) (runtime.Object, error)

type GlobalDNSProviderController 

type GlobalDNSProviderController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() GlobalDNSProviderLister
	AddHandler(ctx context.Context, name string, handler GlobalDNSProviderHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalDNSProviderHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GlobalDNSProviderHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler GlobalDNSProviderHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type GlobalDNSProviderHandlerFunc 

type GlobalDNSProviderHandlerFunc func(key string, obj *GlobalDNSProvider) (runtime.Object, error)

func NewGlobalDNSProviderLifecycleAdapter 

func NewGlobalDNSProviderLifecycleAdapter(name string, clusterScoped bool, client GlobalDNSProviderInterface, l GlobalDNSProviderLifecycle) GlobalDNSProviderHandlerFunc

type GlobalDNSProviderInterface 

type GlobalDNSProviderInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*GlobalDNSProvider) (*GlobalDNSProvider, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*GlobalDNSProvider, error)
	Get(name string, opts metav1.GetOptions) (*GlobalDNSProvider, error)
	Update(*GlobalDNSProvider) (*GlobalDNSProvider, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*GlobalDNSProviderList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*GlobalDNSProviderList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() GlobalDNSProviderController
	AddHandler(ctx context.Context, name string, sync GlobalDNSProviderHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalDNSProviderHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle GlobalDNSProviderLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle GlobalDNSProviderLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalDNSProviderHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync GlobalDNSProviderHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalDNSProviderLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle GlobalDNSProviderLifecycle)
}

type GlobalDNSProviderLifecycle 

type GlobalDNSProviderLifecycle interface {
	Create(obj *GlobalDNSProvider) (runtime.Object, error)
	Remove(obj *GlobalDNSProvider) (runtime.Object, error)
	Updated(obj *GlobalDNSProvider) (runtime.Object, error)
}

type GlobalDNSProviderList 

type GlobalDNSProviderList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []GlobalDNSProvider `json:"items"`
}

func (*GlobalDNSProviderList) DeepCopy 

func (in *GlobalDNSProviderList) DeepCopy() *GlobalDNSProviderList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalDNSProviderList.

func (*GlobalDNSProviderList) DeepCopyInto 

func (in *GlobalDNSProviderList) DeepCopyInto(out *GlobalDNSProviderList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalDNSProviderList) DeepCopyObject 

func (in *GlobalDNSProviderList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalDNSProviderLister 

type GlobalDNSProviderLister interface {
	List(namespace string, selector labels.Selector) (ret []*GlobalDNSProvider, err error)
	Get(namespace, name string) (*GlobalDNSProvider, error)
}

type GlobalDNSProviderSpec 

type GlobalDNSProviderSpec struct {
	Route53ProviderConfig    *Route53ProviderConfig    `json:"route53ProviderConfig,omitempty"`
	CloudflareProviderConfig *CloudflareProviderConfig `json:"cloudflareProviderConfig,omitempty"`
	AlidnsProviderConfig     *AlidnsProviderConfig     `json:"alidnsProviderConfig,omitempty"`
	Members                  []Member                  `json:"members,omitempty"`
	RootDomain               string                    `json:"rootDomain"`
}

func (*GlobalDNSProviderSpec) DeepCopy 

func (in *GlobalDNSProviderSpec) DeepCopy() *GlobalDNSProviderSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalDNSProviderSpec.

func (*GlobalDNSProviderSpec) DeepCopyInto 

func (in *GlobalDNSProviderSpec) DeepCopyInto(out *GlobalDNSProviderSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GlobalDNSProvidersGetter 

type GlobalDNSProvidersGetter interface {
	GlobalDNSProviders(namespace string) GlobalDNSProviderInterface
}

type GlobalDNSSpec 

type GlobalDNSSpec struct {
	FQDN                string   `json:"fqdn,omitempty" norman:"type=hostname,required"`
	TTL                 int64    `json:"ttl,omitempty" norman:"default=300"`
	ProjectNames        []string `json:"projectNames" norman:"type=array[reference[project]],noupdate"`
	MultiClusterAppName string   `json:"multiClusterAppName,omitempty" norman:"type=reference[multiClusterApp]"`
	ProviderName        string   `json:"providerName,omitempty" norman:"type=reference[globalDnsProvider],required"`
	Members             []Member `json:"members,omitempty"`
}

func (*GlobalDNSSpec) DeepCopy 

func (in *GlobalDNSSpec) DeepCopy() *GlobalDNSSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalDNSSpec.

func (*GlobalDNSSpec) DeepCopyInto 

func (in *GlobalDNSSpec) DeepCopyInto(out *GlobalDNSSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GlobalDNSStatus 

type GlobalDNSStatus struct {
	Endpoints        []string            `json:"endpoints,omitempty"`
	ClusterEndpoints map[string][]string `json:"clusterEndpoints,omitempty"`
}

func (*GlobalDNSStatus) DeepCopy 

func (in *GlobalDNSStatus) DeepCopy() *GlobalDNSStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalDNSStatus.

func (*GlobalDNSStatus) DeepCopyInto 

func (in *GlobalDNSStatus) DeepCopyInto(out *GlobalDNSStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GlobalDNSsGetter 

type GlobalDNSsGetter interface {
	GlobalDNSs(namespace string) GlobalDNSInterface
}

type GlobalOpenstackOpts 

type GlobalOpenstackOpts struct {
	AuthURL    string `json:"auth-url" yaml:"auth-url" ini:"auth-url,omitempty"`
	Username   string `json:"username" yaml:"username" ini:"username,omitempty"`
	UserID     string `json:"user-id" yaml:"user-id" ini:"user-id,omitempty"`
	Password   string `json:"password" yaml:"password" ini:"password,omitempty" norman:"type=password"`
	TenantID   string `json:"tenant-id" yaml:"tenant-id" ini:"tenant-id,omitempty"`
	TenantName string `json:"tenant-name" yaml:"tenant-name" ini:"tenant-name,omitempty"`
	TrustID    string `json:"trust-id" yaml:"trust-id" ini:"trust-id,omitempty"`
	DomainID   string `json:"domain-id" yaml:"domain-id" ini:"domain-id,omitempty"`
	DomainName string `json:"domain-name" yaml:"domain-name" ini:"domain-name,omitempty"`
	Region     string `json:"region" yaml:"region" ini:"region,omitempty"`
	CAFile     string `json:"ca-file" yaml:"ca-file" ini:"ca-file,omitempty"`
}

func (*GlobalOpenstackOpts) DeepCopy 

func (in *GlobalOpenstackOpts) DeepCopy() *GlobalOpenstackOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalOpenstackOpts.

func (*GlobalOpenstackOpts) DeepCopyInto 

func (in *GlobalOpenstackOpts) DeepCopyInto(out *GlobalOpenstackOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GlobalRole 

type GlobalRole struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	DisplayName    string              `json:"displayName,omitempty" norman:"required"`
	Description    string              `json:"description"`
	Rules          []rbacv1.PolicyRule `json:"rules,omitempty"`
	NewUserDefault bool                `json:"newUserDefault,omitempty" norman:"required"`
	Builtin        bool                `json:"builtin" norman:"nocreate,noupdate"`
}

func NewGlobalRole 

func NewGlobalRole(namespace, name string, obj GlobalRole) *GlobalRole

func (*GlobalRole) DeepCopy 

func (in *GlobalRole) DeepCopy() *GlobalRole

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalRole.

func (*GlobalRole) DeepCopyInto 

func (in *GlobalRole) DeepCopyInto(out *GlobalRole)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalRole) DeepCopyObject 

func (in *GlobalRole) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalRoleBinding 

type GlobalRoleBinding struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	UserName           string `json:"userName,omitempty" norman:"noupdate,type=reference[user]"`
	GroupPrincipalName string `json:"groupPrincipalName,omitempty" norman:"noupdate,type=reference[principal]"`
	GlobalRoleName     string `json:"globalRoleName,omitempty" norman:"required,noupdate,type=reference[globalRole]"`
}

func NewGlobalRoleBinding 

func NewGlobalRoleBinding(namespace, name string, obj GlobalRoleBinding) *GlobalRoleBinding

func (*GlobalRoleBinding) DeepCopy 

func (in *GlobalRoleBinding) DeepCopy() *GlobalRoleBinding

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalRoleBinding.

func (*GlobalRoleBinding) DeepCopyInto 

func (in *GlobalRoleBinding) DeepCopyInto(out *GlobalRoleBinding)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalRoleBinding) DeepCopyObject 

func (in *GlobalRoleBinding) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalRoleBindingChangeHandlerFunc 

type GlobalRoleBindingChangeHandlerFunc func(obj *GlobalRoleBinding) (runtime.Object, error)

type GlobalRoleBindingController 

type GlobalRoleBindingController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() GlobalRoleBindingLister
	AddHandler(ctx context.Context, name string, handler GlobalRoleBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalRoleBindingHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GlobalRoleBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler GlobalRoleBindingHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type GlobalRoleBindingHandlerFunc 

type GlobalRoleBindingHandlerFunc func(key string, obj *GlobalRoleBinding) (runtime.Object, error)

func NewGlobalRoleBindingLifecycleAdapter 

func NewGlobalRoleBindingLifecycleAdapter(name string, clusterScoped bool, client GlobalRoleBindingInterface, l GlobalRoleBindingLifecycle) GlobalRoleBindingHandlerFunc

type GlobalRoleBindingInterface 

type GlobalRoleBindingInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*GlobalRoleBinding) (*GlobalRoleBinding, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*GlobalRoleBinding, error)
	Get(name string, opts metav1.GetOptions) (*GlobalRoleBinding, error)
	Update(*GlobalRoleBinding) (*GlobalRoleBinding, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*GlobalRoleBindingList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*GlobalRoleBindingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() GlobalRoleBindingController
	AddHandler(ctx context.Context, name string, sync GlobalRoleBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalRoleBindingHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle GlobalRoleBindingLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle GlobalRoleBindingLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalRoleBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync GlobalRoleBindingHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalRoleBindingLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle GlobalRoleBindingLifecycle)
}

type GlobalRoleBindingLifecycle 

type GlobalRoleBindingLifecycle interface {
	Create(obj *GlobalRoleBinding) (runtime.Object, error)
	Remove(obj *GlobalRoleBinding) (runtime.Object, error)
	Updated(obj *GlobalRoleBinding) (runtime.Object, error)
}

type GlobalRoleBindingList 

type GlobalRoleBindingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []GlobalRoleBinding `json:"items"`
}

func (*GlobalRoleBindingList) DeepCopy 

func (in *GlobalRoleBindingList) DeepCopy() *GlobalRoleBindingList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalRoleBindingList.

func (*GlobalRoleBindingList) DeepCopyInto 

func (in *GlobalRoleBindingList) DeepCopyInto(out *GlobalRoleBindingList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalRoleBindingList) DeepCopyObject 

func (in *GlobalRoleBindingList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalRoleBindingLister 

type GlobalRoleBindingLister interface {
	List(namespace string, selector labels.Selector) (ret []*GlobalRoleBinding, err error)
	Get(namespace, name string) (*GlobalRoleBinding, error)
}

type GlobalRoleBindingsGetter 

type GlobalRoleBindingsGetter interface {
	GlobalRoleBindings(namespace string) GlobalRoleBindingInterface
}

type GlobalRoleChangeHandlerFunc 

type GlobalRoleChangeHandlerFunc func(obj *GlobalRole) (runtime.Object, error)

type GlobalRoleController 

type GlobalRoleController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() GlobalRoleLister
	AddHandler(ctx context.Context, name string, handler GlobalRoleHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalRoleHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GlobalRoleHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler GlobalRoleHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type GlobalRoleHandlerFunc 

type GlobalRoleHandlerFunc func(key string, obj *GlobalRole) (runtime.Object, error)

func NewGlobalRoleLifecycleAdapter 

func NewGlobalRoleLifecycleAdapter(name string, clusterScoped bool, client GlobalRoleInterface, l GlobalRoleLifecycle) GlobalRoleHandlerFunc

type GlobalRoleInterface 

type GlobalRoleInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*GlobalRole) (*GlobalRole, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*GlobalRole, error)
	Get(name string, opts metav1.GetOptions) (*GlobalRole, error)
	Update(*GlobalRole) (*GlobalRole, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*GlobalRoleList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*GlobalRoleList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() GlobalRoleController
	AddHandler(ctx context.Context, name string, sync GlobalRoleHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GlobalRoleHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle GlobalRoleLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle GlobalRoleLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalRoleHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync GlobalRoleHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalRoleLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle GlobalRoleLifecycle)
}

type GlobalRoleLifecycle 

type GlobalRoleLifecycle interface {
	Create(obj *GlobalRole) (runtime.Object, error)
	Remove(obj *GlobalRole) (runtime.Object, error)
	Updated(obj *GlobalRole) (runtime.Object, error)
}

type GlobalRoleList 

type GlobalRoleList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []GlobalRole `json:"items"`
}

func (*GlobalRoleList) DeepCopy 

func (in *GlobalRoleList) DeepCopy() *GlobalRoleList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalRoleList.

func (*GlobalRoleList) DeepCopyInto 

func (in *GlobalRoleList) DeepCopyInto(out *GlobalRoleList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GlobalRoleList) DeepCopyObject 

func (in *GlobalRoleList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GlobalRoleLister 

type GlobalRoleLister interface {
	List(namespace string, selector labels.Selector) (ret []*GlobalRole, err error)
	Get(namespace, name string) (*GlobalRole, error)
}

type GlobalRolesGetter 

type GlobalRolesGetter interface {
	GlobalRoles(namespace string) GlobalRoleInterface
}

type GlobalVsphereOpts 

type GlobalVsphereOpts struct {
	User              string `json:"user,omitempty" yaml:"user,omitempty" ini:"user,omitempty"`
	Password          string `json:"password,omitempty" yaml:"password,omitempty" ini:"password,omitempty" norman:"type=password"`
	VCenterIP         string `json:"server,omitempty" yaml:"server,omitempty" ini:"server,omitempty"`
	VCenterPort       string `json:"port,omitempty" yaml:"port,omitempty" ini:"port,omitempty"`
	InsecureFlag      bool   `json:"insecure-flag,omitempty" yaml:"insecure-flag,omitempty" ini:"insecure-flag,omitempty"`
	Datacenter        string `json:"datacenter,omitempty" yaml:"datacenter,omitempty" ini:"datacenter,omitempty"`
	Datacenters       string `json:"datacenters,omitempty" yaml:"datacenters,omitempty" ini:"datacenters,omitempty"`
	DefaultDatastore  string `json:"datastore,omitempty" yaml:"datastore,omitempty" ini:"datastore,omitempty"`
	WorkingDir        string `json:"working-dir,omitempty" yaml:"working-dir,omitempty" ini:"working-dir,omitempty"`
	RoundTripperCount int    `json:"soap-roundtrip-count,omitempty" yaml:"soap-roundtrip-count,omitempty" ini:"soap-roundtrip-count,omitempty"`
	VMUUID            string `json:"vm-uuid,omitempty" yaml:"vm-uuid,omitempty" ini:"vm-uuid,omitempty"`
	VMName            string `json:"vm-name,omitempty" yaml:"vm-name,omitempty" ini:"vm-name,omitempty"`
}

func (*GlobalVsphereOpts) DeepCopy 

func (in *GlobalVsphereOpts) DeepCopy() *GlobalVsphereOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalVsphereOpts.

func (*GlobalVsphereOpts) DeepCopyInto 

func (in *GlobalVsphereOpts) DeepCopyInto(out *GlobalVsphereOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GoogleOauthConfig 

type GoogleOauthConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	AuthConfig        `json:",inline" mapstructure:",squash"`

	OauthCredential              string `json:"oauthCredential,omitempty" norman:"required,type=password,notnullable"`
	ServiceAccountCredential     string `json:"serviceAccountCredential,omitempty" norman:"required,type=password,notnullable"`
	AdminEmail                   string `json:"adminEmail,omitempty" norman:"required,notnullable"`
	Hostname                     string `json:"hostname,omitempty" norman:"required,notnullable,noupdate"`
	UserInfoEndpoint             string `json:"userInfoEndpoint" norman:"default=https://openidconnect.googleapis.com/v1/userinfo,required,notnullable"`
	NestedGroupMembershipEnabled bool   `json:"nestedGroupMembershipEnabled"    norman:"default=false"`
}

func (*GoogleOauthConfig) DeepCopy 

func (in *GoogleOauthConfig) DeepCopy() *GoogleOauthConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GoogleOauthConfig.

func (*GoogleOauthConfig) DeepCopyInto 

func (in *GoogleOauthConfig) DeepCopyInto(out *GoogleOauthConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GoogleOauthConfig) DeepCopyObject 

func (in *GoogleOauthConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GoogleOauthConfigApplyInput 

type GoogleOauthConfigApplyInput struct {
	GoogleOauthConfig GoogleOauthConfig `json:"googleOauthConfig,omitempty"`
	Code              string            `json:"code,omitempty"`
	Enabled           bool              `json:"enabled,omitempty"`
}

func (*GoogleOauthConfigApplyInput) DeepCopy 

func (in *GoogleOauthConfigApplyInput) DeepCopy() *GoogleOauthConfigApplyInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GoogleOauthConfigApplyInput.

func (*GoogleOauthConfigApplyInput) DeepCopyInto 

func (in *GoogleOauthConfigApplyInput) DeepCopyInto(out *GoogleOauthConfigApplyInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GoogleOauthConfigTestOutput 

type GoogleOauthConfigTestOutput struct {
	RedirectURL string `json:"redirectUrl"`
}

func (*GoogleOauthConfigTestOutput) DeepCopy 

func (in *GoogleOauthConfigTestOutput) DeepCopy() *GoogleOauthConfigTestOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GoogleOauthConfigTestOutput.

func (*GoogleOauthConfigTestOutput) DeepCopyInto 

func (in *GoogleOauthConfigTestOutput) DeepCopyInto(out *GoogleOauthConfigTestOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Group 

type Group struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	DisplayName string `json:"displayName,omitempty"`
}

func NewGroup 

func NewGroup(namespace, name string, obj Group) *Group

func (*Group) DeepCopy 

func (in *Group) DeepCopy() *Group

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Group.

func (*Group) DeepCopyInto 

func (in *Group) DeepCopyInto(out *Group)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Group) DeepCopyObject 

func (in *Group) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GroupChangeHandlerFunc 

type GroupChangeHandlerFunc func(obj *Group) (runtime.Object, error)

type GroupController 

type GroupController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() GroupLister
	AddHandler(ctx context.Context, name string, handler GroupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GroupHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GroupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler GroupHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type GroupHandlerFunc 

type GroupHandlerFunc func(key string, obj *Group) (runtime.Object, error)

func NewGroupLifecycleAdapter 

func NewGroupLifecycleAdapter(name string, clusterScoped bool, client GroupInterface, l GroupLifecycle) GroupHandlerFunc

type GroupInterface 

type GroupInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Group) (*Group, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Group, error)
	Get(name string, opts metav1.GetOptions) (*Group, error)
	Update(*Group) (*Group, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*GroupList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*GroupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() GroupController
	AddHandler(ctx context.Context, name string, sync GroupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GroupHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle GroupLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle GroupLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GroupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync GroupHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GroupLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle GroupLifecycle)
}

type GroupLifecycle 

type GroupLifecycle interface {
	Create(obj *Group) (runtime.Object, error)
	Remove(obj *Group) (runtime.Object, error)
	Updated(obj *Group) (runtime.Object, error)
}

type GroupList 

type GroupList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Group `json:"items"`
}

func (*GroupList) DeepCopy 

func (in *GroupList) DeepCopy() *GroupList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GroupList.

func (*GroupList) DeepCopyInto 

func (in *GroupList) DeepCopyInto(out *GroupList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GroupList) DeepCopyObject 

func (in *GroupList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GroupLister 

type GroupLister interface {
	List(namespace string, selector labels.Selector) (ret []*Group, err error)
	Get(namespace, name string) (*Group, error)
}

type GroupMember 

type GroupMember struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	GroupName   string `json:"groupName,omitempty" norman:"type=reference[group]"`
	PrincipalID string `json:"principalId,omitempty" norman:"type=reference[principal]"`
}

func NewGroupMember 

func NewGroupMember(namespace, name string, obj GroupMember) *GroupMember

func (*GroupMember) DeepCopy 

func (in *GroupMember) DeepCopy() *GroupMember

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GroupMember.

func (*GroupMember) DeepCopyInto 

func (in *GroupMember) DeepCopyInto(out *GroupMember)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GroupMember) DeepCopyObject 

func (in *GroupMember) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GroupMemberChangeHandlerFunc 

type GroupMemberChangeHandlerFunc func(obj *GroupMember) (runtime.Object, error)

type GroupMemberController 

type GroupMemberController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() GroupMemberLister
	AddHandler(ctx context.Context, name string, handler GroupMemberHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GroupMemberHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GroupMemberHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler GroupMemberHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type GroupMemberHandlerFunc 

type GroupMemberHandlerFunc func(key string, obj *GroupMember) (runtime.Object, error)

func NewGroupMemberLifecycleAdapter 

func NewGroupMemberLifecycleAdapter(name string, clusterScoped bool, client GroupMemberInterface, l GroupMemberLifecycle) GroupMemberHandlerFunc

type GroupMemberInterface 

type GroupMemberInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*GroupMember) (*GroupMember, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*GroupMember, error)
	Get(name string, opts metav1.GetOptions) (*GroupMember, error)
	Update(*GroupMember) (*GroupMember, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*GroupMemberList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*GroupMemberList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() GroupMemberController
	AddHandler(ctx context.Context, name string, sync GroupMemberHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync GroupMemberHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle GroupMemberLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle GroupMemberLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GroupMemberHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync GroupMemberHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GroupMemberLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle GroupMemberLifecycle)
}

type GroupMemberLifecycle 

type GroupMemberLifecycle interface {
	Create(obj *GroupMember) (runtime.Object, error)
	Remove(obj *GroupMember) (runtime.Object, error)
	Updated(obj *GroupMember) (runtime.Object, error)
}

type GroupMemberList 

type GroupMemberList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []GroupMember `json:"items"`
}

func (*GroupMemberList) DeepCopy 

func (in *GroupMemberList) DeepCopy() *GroupMemberList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GroupMemberList.

func (*GroupMemberList) DeepCopyInto 

func (in *GroupMemberList) DeepCopyInto(out *GroupMemberList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*GroupMemberList) DeepCopyObject 

func (in *GroupMemberList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type GroupMemberLister 

type GroupMemberLister interface {
	List(namespace string, selector labels.Selector) (ret []*GroupMember, err error)
	Get(namespace, name string) (*GroupMember, error)
}

type GroupMembersGetter 

type GroupMembersGetter interface {
	GroupMembers(namespace string) GroupMemberInterface
}

type GroupsGetter 

type GroupsGetter interface {
	Groups(namespace string) GroupInterface
}

type HTTPClientConfig 

type HTTPClientConfig struct {
	// HTTP proxy server to use to connect to the targets.
	ProxyURL string `json:"proxyUrl,omitempty"`
}

HTTPClientConfig configures an HTTP client.

func (*HTTPClientConfig) DeepCopy 

func (in *HTTPClientConfig) DeepCopy() *HTTPClientConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPClientConfig.

func (*HTTPClientConfig) DeepCopyInto 

func (in *HTTPClientConfig) DeepCopyInto(out *HTTPClientConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type HealthCheck 

type HealthCheck struct {
	// Healthcheck URL
	URL string `json:"url,omitempty"`
}

func (*HealthCheck) DeepCopy 

func (in *HealthCheck) DeepCopy() *HealthCheck

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HealthCheck.

func (*HealthCheck) DeepCopyInto 

func (in *HealthCheck) DeepCopyInto(out *HealthCheck)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ImportClusterYamlInput 

type ImportClusterYamlInput struct {
	YAML             string `json:"yaml,omitempty"`
	DefaultNamespace string `json:"defaultNamespace,omitempty"`
	Namespace        string `json:"namespace,omitempty"`
	ProjectName      string `json:"projectName,omitempty" norman:"type=reference[project]"`
}

func (*ImportClusterYamlInput) DeepCopy 

func (in *ImportClusterYamlInput) DeepCopy() *ImportClusterYamlInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImportClusterYamlInput.

func (*ImportClusterYamlInput) DeepCopyInto 

func (in *ImportClusterYamlInput) DeepCopyInto(out *ImportClusterYamlInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ImportClusterYamlInput) ObjClusterName 

func (i *ImportClusterYamlInput) ObjClusterName() string

type ImportYamlOutput 

type ImportYamlOutput struct {
	Message string `json:"message,omitempty"`
}

func (*ImportYamlOutput) DeepCopy 

func (in *ImportYamlOutput) DeepCopy() *ImportYamlOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImportYamlOutput.

func (*ImportYamlOutput) DeepCopyInto 

func (in *ImportYamlOutput) DeepCopyInto(out *ImportYamlOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ImportedConfig 

type ImportedConfig struct {
	KubeConfig string `json:"kubeConfig" norman:"type=password"`
}

func (*ImportedConfig) DeepCopy 

func (in *ImportedConfig) DeepCopy() *ImportedConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImportedConfig.

func (*ImportedConfig) DeepCopyInto 

func (in *ImportedConfig) DeepCopyInto(out *ImportedConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type IngressCapabilities 

type IngressCapabilities struct {
	IngressProvider      string `json:"ingressProvider,omitempty"`
	CustomDefaultBackend *bool  `json:"customDefaultBackend,omitempty"`
}

func (*IngressCapabilities) DeepCopy 

func (in *IngressCapabilities) DeepCopy() *IngressCapabilities

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressCapabilities.

func (*IngressCapabilities) DeepCopyInto 

func (in *IngressCapabilities) DeepCopyInto(out *IngressCapabilities)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type IngressConfig 

type IngressConfig struct {
	// Ingress controller type used by kubernetes
	Provider string `yaml:"provider" json:"provider,omitempty" norman:"default=nginx"`
	// Ingress controller options
	Options map[string]string `yaml:"options" json:"options,omitempty"`
	// NodeSelector key pair
	NodeSelector map[string]string `yaml:"node_selector" json:"nodeSelector,omitempty"`
	// Ingress controller extra arguments
	ExtraArgs map[string]string `yaml:"extra_args" json:"extraArgs,omitempty"`
	// DNS Policy
	DNSPolicy string `yaml:"dns_policy" json:"dnsPolicy,omitempty"`
	// Extra Env vars
	ExtraEnvs []ExtraEnv `yaml:"extra_envs" json:"extraEnvs,omitempty" norman:"type=array[json]"`
	// Extra volumes
	ExtraVolumes []ExtraVolume `yaml:"extra_volumes" json:"extraVolumes,omitempty" norman:"type=array[json]"`
	// Extra volume mounts
	ExtraVolumeMounts []ExtraVolumeMount `yaml:"extra_volume_mounts" json:"extraVolumeMounts,omitempty" norman:"type=array[json]"`
	// nginx daemonset upgrade strategy
	UpdateStrategy *DaemonSetUpdateStrategy `yaml:"update_strategy" json:"updateStrategy,omitempty"`
	// Http port for ingress controller daemonset
	HTTPPort int `yaml:"http_port" json:"httpPort,omitempty"`
	// Https port for ingress controller daemonset
	HTTPSPort int `yaml:"https_port" json:"httpsPort,omitempty"`
	// NetworkMode selector for ingress controller pods. Default is HostNetwork
	NetworkMode string `yaml:"network_mode" json:"networkMode,omitempty"`
	// Tolerations for Deployments
	Tolerations []v1.Toleration `yaml:"tolerations" json:"tolerations,omitempty"`
}

func (*IngressConfig) DeepCopy 

func (in *IngressConfig) DeepCopy() *IngressConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressConfig.

func (*IngressConfig) DeepCopyInto 

func (in *IngressConfig) DeepCopyInto(out *IngressConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Interface 

type Interface interface {
	RESTClient() rest.Interface
	controller.Starter

	NodePoolsGetter
	NodesGetter
	NodeDriversGetter
	NodeTemplatesGetter
	ProjectsGetter
	GlobalRolesGetter
	GlobalRoleBindingsGetter
	RoleTemplatesGetter
	PodSecurityPolicyTemplatesGetter
	PodSecurityPolicyTemplateProjectBindingsGetter
	ClusterRoleTemplateBindingsGetter
	ProjectRoleTemplateBindingsGetter
	ClustersGetter
	ClusterRegistrationTokensGetter
	CatalogsGetter
	TemplatesGetter
	CatalogTemplatesGetter
	CatalogTemplateVersionsGetter
	TemplateVersionsGetter
	TemplateContentsGetter
	GroupsGetter
	GroupMembersGetter
	SamlTokensGetter
	PrincipalsGetter
	UsersGetter
	AuthConfigsGetter
	LdapConfigsGetter
	TokensGetter
	DynamicSchemasGetter
	PreferencesGetter
	UserAttributesGetter
	ProjectNetworkPoliciesGetter
	ClusterLoggingsGetter
	ProjectLoggingsGetter
	SettingsGetter
	FeaturesGetter
	ClusterAlertsGetter
	ProjectAlertsGetter
	NotifiersGetter
	ClusterAlertGroupsGetter
	ProjectAlertGroupsGetter
	ClusterAlertRulesGetter
	ProjectAlertRulesGetter
	ComposeConfigsGetter
	ProjectCatalogsGetter
	ClusterCatalogsGetter
	MultiClusterAppsGetter
	MultiClusterAppRevisionsGetter
	GlobalDNSsGetter
	GlobalDNSProvidersGetter
	KontainerDriversGetter
	EtcdBackupsGetter
	ClusterScansGetter
	MonitorMetricsGetter
	ClusterMonitorGraphsGetter
	ProjectMonitorGraphsGetter
	CloudCredentialsGetter
	ClusterTemplatesGetter
	ClusterTemplateRevisionsGetter
	RKEK8sSystemImagesGetter
	RKEK8sServiceOptionsGetter
	RKEAddonsGetter
	CisConfigsGetter
	CisBenchmarkVersionsGetter
}

func NewForConfig 

func NewForConfig(config rest.Config) (Interface, error)

type K3sConfig 

type K3sConfig struct {
	// k3s Kubernetes version, unset the value indicates an unmanaged cluster
	Version            string `yaml:"kubernetes_version" json:"kubernetesVersion,omitempty"`
	K3sUpgradeStrategy `yaml:"k3s_upgrade_strategy,omitempty" json:"k3supgradeStrategy,omitempty"`
}

K3sConfig provides desired configuration for k3s clusters

func (*K3sConfig) DeepCopy 

func (in *K3sConfig) DeepCopy() *K3sConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new K3sConfig.

func (*K3sConfig) DeepCopyInto 

func (in *K3sConfig) DeepCopyInto(out *K3sConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type K3sUpgradeStrategy 

type K3sUpgradeStrategy struct {
	// How many controlplane nodes should be upgrade at time, defaults to 1
	ServerConcurrency int `yaml:"server_concurrency" json:"serverConcurrency,omitempty" norman:"min=1"`
	// How many workers should be upgraded at a time
	WorkerConcurrency int `yaml:"worker_concurrency" json:"workerConcurrency,omitempty" norman:"min=1"`
	// Whether controlplane nodes should be drained
	DrainServerNodes bool `yaml:"drain_server_nodes" json:"drainServerNodes,omitempty"`
	// Whether worker nodes should be drained
	DrainWorkerNodes bool `yaml:"drain_worker_nodes" json:"drainWorkerNodes,omitempty"`
}

K3sUpgradeStrategy provides configuration to the downstream system-upgrade-controller

func (*K3sUpgradeStrategy) DeepCopy 

func (in *K3sUpgradeStrategy) DeepCopy() *K3sUpgradeStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new K3sUpgradeStrategy.

func (*K3sUpgradeStrategy) DeepCopyInto 

func (in *K3sUpgradeStrategy) DeepCopyInto(out *K3sUpgradeStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type K8sVersionInfo 

type K8sVersionInfo struct {
	MinRKEVersion       string `yaml:"min_rke_version" json:"minRKEVersion,omitempty"`
	MaxRKEVersion       string `yaml:"max_rke_version" json:"maxRKEVersion,omitempty"`
	DeprecateRKEVersion string `yaml:"deprecate_rke_version" json:"deprecateRKEVersion,omitempty"`

	MinRancherVersion       string `yaml:"min_rancher_version" json:"minRancherVersion,omitempty"`
	MaxRancherVersion       string `yaml:"max_rancher_version" json:"maxRancherVersion,omitempty"`
	DeprecateRancherVersion string `yaml:"deprecate_rancher_version" json:"deprecateRancherVersion,omitempty"`
}

func (*K8sVersionInfo) DeepCopy 

func (in *K8sVersionInfo) DeepCopy() *K8sVersionInfo

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new K8sVersionInfo.

func (*K8sVersionInfo) DeepCopyInto 

func (in *K8sVersionInfo) DeepCopyInto(out *K8sVersionInfo)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KafkaConfig 

type KafkaConfig struct {
	ZookeeperEndpoint  string   `json:"zookeeperEndpoint,omitempty"`
	BrokerEndpoints    []string `json:"brokerEndpoints,omitempty"`
	Topic              string   `json:"topic,omitempty" norman:"required"`
	Certificate        string   `json:"certificate,omitempty"`
	ClientCert         string   `json:"clientCert,omitempty"`
	ClientKey          string   `json:"clientKey,omitempty"`
	SaslUsername       string   `json:"saslUsername,omitempty"`
	SaslPassword       string   `json:"saslPassword,omitempty" norman:"type=password"`
	SaslScramMechanism string   `json:"saslScramMechanism,omitempty" norman:"type=enum,options=sha256|sha512"`
	SaslType           string   `json:"saslType,omitempty" norman:"type=enum,options=plain|scram"`
}

func (*KafkaConfig) DeepCopy 

func (in *KafkaConfig) DeepCopy() *KafkaConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KafkaConfig.

func (*KafkaConfig) DeepCopyInto 

func (in *KafkaConfig) DeepCopyInto(out *KafkaConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KeyCloakConfig 

type KeyCloakConfig struct {
	SamlConfig `json:",inline" mapstructure:",squash"`
}

func (*KeyCloakConfig) DeepCopy 

func (in *KeyCloakConfig) DeepCopy() *KeyCloakConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KeyCloakConfig.

func (*KeyCloakConfig) DeepCopyInto 

func (in *KeyCloakConfig) DeepCopyInto(out *KeyCloakConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*KeyCloakConfig) DeepCopyObject 

func (in *KeyCloakConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type KontainerDriver 

type KontainerDriver struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec KontainerDriverSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status KontainerDriverStatus `json:"status"`
}

func NewKontainerDriver 

func NewKontainerDriver(namespace, name string, obj KontainerDriver) *KontainerDriver

func (*KontainerDriver) DeepCopy 

func (in *KontainerDriver) DeepCopy() *KontainerDriver

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KontainerDriver.

func (*KontainerDriver) DeepCopyInto 

func (in *KontainerDriver) DeepCopyInto(out *KontainerDriver)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*KontainerDriver) DeepCopyObject 

func (in *KontainerDriver) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type KontainerDriverChangeHandlerFunc 

type KontainerDriverChangeHandlerFunc func(obj *KontainerDriver) (runtime.Object, error)

type KontainerDriverController 

type KontainerDriverController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() KontainerDriverLister
	AddHandler(ctx context.Context, name string, handler KontainerDriverHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync KontainerDriverHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler KontainerDriverHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler KontainerDriverHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type KontainerDriverHandlerFunc 

type KontainerDriverHandlerFunc func(key string, obj *KontainerDriver) (runtime.Object, error)

func NewKontainerDriverLifecycleAdapter 

func NewKontainerDriverLifecycleAdapter(name string, clusterScoped bool, client KontainerDriverInterface, l KontainerDriverLifecycle) KontainerDriverHandlerFunc

type KontainerDriverInterface 

type KontainerDriverInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*KontainerDriver) (*KontainerDriver, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*KontainerDriver, error)
	Get(name string, opts metav1.GetOptions) (*KontainerDriver, error)
	Update(*KontainerDriver) (*KontainerDriver, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*KontainerDriverList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*KontainerDriverList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() KontainerDriverController
	AddHandler(ctx context.Context, name string, sync KontainerDriverHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync KontainerDriverHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle KontainerDriverLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle KontainerDriverLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync KontainerDriverHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync KontainerDriverHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle KontainerDriverLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle KontainerDriverLifecycle)
}

type KontainerDriverLifecycle 

type KontainerDriverLifecycle interface {
	Create(obj *KontainerDriver) (runtime.Object, error)
	Remove(obj *KontainerDriver) (runtime.Object, error)
	Updated(obj *KontainerDriver) (runtime.Object, error)
}

type KontainerDriverList 

type KontainerDriverList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []KontainerDriver `json:"items"`
}

func (*KontainerDriverList) DeepCopy 

func (in *KontainerDriverList) DeepCopy() *KontainerDriverList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KontainerDriverList.

func (*KontainerDriverList) DeepCopyInto 

func (in *KontainerDriverList) DeepCopyInto(out *KontainerDriverList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*KontainerDriverList) DeepCopyObject 

func (in *KontainerDriverList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type KontainerDriverLister 

type KontainerDriverLister interface {
	List(namespace string, selector labels.Selector) (ret []*KontainerDriver, err error)
	Get(namespace, name string) (*KontainerDriver, error)
}

type KontainerDriverSpec 

type KontainerDriverSpec struct {
	URL              string   `json:"url" norman:"required"`
	Checksum         string   `json:"checksum"`
	BuiltIn          bool     `json:"builtIn" norman:"noupdate"`
	Active           bool     `json:"active"`
	UIURL            string   `json:"uiUrl"`
	WhitelistDomains []string `json:"whitelistDomains,omitempty"`
}

func (*KontainerDriverSpec) DeepCopy 

func (in *KontainerDriverSpec) DeepCopy() *KontainerDriverSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KontainerDriverSpec.

func (*KontainerDriverSpec) DeepCopyInto 

func (in *KontainerDriverSpec) DeepCopyInto(out *KontainerDriverSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KontainerDriverStatus 

type KontainerDriverStatus struct {
	ActualURL      string      `json:"actualUrl"`
	ExecutablePath string      `json:"executablePath"`
	Conditions     []Condition `json:"conditions"`
	DisplayName    string      `json:"displayName"`
}

func (*KontainerDriverStatus) DeepCopy 

func (in *KontainerDriverStatus) DeepCopy() *KontainerDriverStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KontainerDriverStatus.

func (*KontainerDriverStatus) DeepCopyInto 

func (in *KontainerDriverStatus) DeepCopyInto(out *KontainerDriverStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KontainerDriversGetter 

type KontainerDriversGetter interface {
	KontainerDrivers(namespace string) KontainerDriverInterface
}

type KubeAPIService 

type KubeAPIService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
	// Virtual IP range that will be used by Kubernetes services
	ServiceClusterIPRange string `yaml:"service_cluster_ip_range" json:"serviceClusterIpRange,omitempty"`
	// Port range for services defined with NodePort type
	ServiceNodePortRange string `yaml:"service_node_port_range" json:"serviceNodePortRange,omitempty" norman:"default=30000-32767"`
	// Enabled/Disable PodSecurityPolicy
	PodSecurityPolicy bool `yaml:"pod_security_policy" json:"podSecurityPolicy,omitempty"`
	// Enable/Disable AlwaysPullImages admissions plugin
	AlwaysPullImages bool `yaml:"always_pull_images" json:"alwaysPullImages,omitempty"`
	// Secrets encryption provider config
	SecretsEncryptionConfig *SecretsEncryptionConfig `yaml:"secrets_encryption_config" json:"secretsEncryptionConfig,omitempty"`
	// Audit Log Configuration
	AuditLog *AuditLog `yaml:"audit_log" json:"auditLog,omitempty"`
	// AdmissionConfiguration
	AdmissionConfiguration *apiserverv1alpha1.AdmissionConfiguration `yaml:"admission_configuration" json:"admissionConfiguration,omitempty" norman:"type=map[json]"`
	// Event Rate Limit configuration
	EventRateLimit *EventRateLimit `yaml:"event_rate_limit" json:"eventRateLimit,omitempty"`
}

func (*KubeAPIService) DeepCopy 

func (in *KubeAPIService) DeepCopy() *KubeAPIService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubeAPIService.

func (*KubeAPIService) DeepCopyInto 

func (in *KubeAPIService) DeepCopyInto(out *KubeAPIService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KubeControllerService 

type KubeControllerService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
	// CIDR Range for Pods in cluster
	ClusterCIDR string `yaml:"cluster_cidr" json:"clusterCidr,omitempty"`
	// Virtual IP range that will be used by Kubernetes services
	ServiceClusterIPRange string `yaml:"service_cluster_ip_range" json:"serviceClusterIpRange,omitempty"`
}

func (*KubeControllerService) DeepCopy 

func (in *KubeControllerService) DeepCopy() *KubeControllerService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubeControllerService.

func (*KubeControllerService) DeepCopyInto 

func (in *KubeControllerService) DeepCopyInto(out *KubeControllerService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KubeletService 

type KubeletService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
	// Domain of the cluster (default: "cluster.local")
	ClusterDomain string `yaml:"cluster_domain" json:"clusterDomain,omitempty"`
	// The image whose network/ipc namespaces containers in each pod will use
	InfraContainerImage string `yaml:"infra_container_image" json:"infraContainerImage,omitempty"`
	// Cluster DNS service ip
	ClusterDNSServer string `yaml:"cluster_dns_server" json:"clusterDnsServer,omitempty"`
	// Fail if swap is enabled
	FailSwapOn bool `yaml:"fail_swap_on" json:"failSwapOn,omitempty"`
	// Generate per node kubelet serving certificates created using kube-ca
	GenerateServingCertificate bool `yaml:"generate_serving_certificate" json:"generateServingCertificate,omitempty"`
}

func (*KubeletService) DeepCopy 

func (in *KubeletService) DeepCopy() *KubeletService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubeletService.

func (*KubeletService) DeepCopyInto 

func (in *KubeletService) DeepCopyInto(out *KubeletService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KubeproxyService 

type KubeproxyService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
}

func (*KubeproxyService) DeepCopy 

func (in *KubeproxyService) DeepCopy() *KubeproxyService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubeproxyService.

func (*KubeproxyService) DeepCopyInto 

func (in *KubeproxyService) DeepCopyInto(out *KubeproxyService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KubernetesServicesOptions 

type KubernetesServicesOptions struct {
	// Additional options passed to Etcd
	Etcd map[string]string `json:"etcd"`
	// Additional options passed to KubeAPI
	KubeAPI map[string]string `json:"kubeapi"`
	// Additional options passed to Kubelet
	Kubelet map[string]string `json:"kubelet"`
	// Additional options passed to Kubeproxy
	Kubeproxy map[string]string `json:"kubeproxy"`
	// Additional options passed to KubeController
	KubeController map[string]string `json:"kubeController"`
	// Additional options passed to Scheduler
	Scheduler map[string]string `json:"scheduler"`
}

func (*KubernetesServicesOptions) DeepCopy 

func (in *KubernetesServicesOptions) DeepCopy() *KubernetesServicesOptions

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubernetesServicesOptions.

func (*KubernetesServicesOptions) DeepCopyInto 

func (in *KubernetesServicesOptions) DeepCopyInto(out *KubernetesServicesOptions)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LdapConfig 

type LdapConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	AuthConfig        `json:",inline" mapstructure:",squash"`
	LdapFields        `json:",inline" mapstructure:",squash"`
}

func NewLdapConfig 

func NewLdapConfig(namespace, name string, obj LdapConfig) *LdapConfig

func (*LdapConfig) DeepCopy 

func (in *LdapConfig) DeepCopy() *LdapConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LdapConfig.

func (*LdapConfig) DeepCopyInto 

func (in *LdapConfig) DeepCopyInto(out *LdapConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*LdapConfig) DeepCopyObject 

func (in *LdapConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type LdapConfigChangeHandlerFunc 

type LdapConfigChangeHandlerFunc func(obj *LdapConfig) (runtime.Object, error)

type LdapConfigController 

type LdapConfigController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() LdapConfigLister
	AddHandler(ctx context.Context, name string, handler LdapConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync LdapConfigHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler LdapConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler LdapConfigHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type LdapConfigHandlerFunc 

type LdapConfigHandlerFunc func(key string, obj *LdapConfig) (runtime.Object, error)

func NewLdapConfigLifecycleAdapter 

func NewLdapConfigLifecycleAdapter(name string, clusterScoped bool, client LdapConfigInterface, l LdapConfigLifecycle) LdapConfigHandlerFunc

type LdapConfigInterface 

type LdapConfigInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*LdapConfig) (*LdapConfig, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*LdapConfig, error)
	Get(name string, opts metav1.GetOptions) (*LdapConfig, error)
	Update(*LdapConfig) (*LdapConfig, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*LdapConfigList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*LdapConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() LdapConfigController
	AddHandler(ctx context.Context, name string, sync LdapConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync LdapConfigHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle LdapConfigLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle LdapConfigLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync LdapConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync LdapConfigHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle LdapConfigLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle LdapConfigLifecycle)
}

type LdapConfigLifecycle 

type LdapConfigLifecycle interface {
	Create(obj *LdapConfig) (runtime.Object, error)
	Remove(obj *LdapConfig) (runtime.Object, error)
	Updated(obj *LdapConfig) (runtime.Object, error)
}

type LdapConfigList 

type LdapConfigList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []LdapConfig `json:"items"`
}

func (*LdapConfigList) DeepCopy 

func (in *LdapConfigList) DeepCopy() *LdapConfigList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LdapConfigList.

func (*LdapConfigList) DeepCopyInto 

func (in *LdapConfigList) DeepCopyInto(out *LdapConfigList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*LdapConfigList) DeepCopyObject 

func (in *LdapConfigList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type LdapConfigLister 

type LdapConfigLister interface {
	List(namespace string, selector labels.Selector) (ret []*LdapConfig, err error)
	Get(namespace, name string) (*LdapConfig, error)
}

type LdapConfigsGetter 

type LdapConfigsGetter interface {
	LdapConfigs(namespace string) LdapConfigInterface
}

type LdapFields 

type LdapFields struct {
	Servers                         []string `json:"servers,omitempty"                         norman:"type=array[string],notnullable,required"`
	Port                            int64    `json:"port,omitempty"                            norman:"default=389,notnullable,required"`
	TLS                             bool     `json:"tls,omitempty"                             norman:"default=false,notnullable,required"`
	StartTLS                        bool     `json:"starttls,omitempty"                        norman:"default=false"`
	Certificate                     string   `json:"certificate,omitempty"`
	ServiceAccountDistinguishedName string   `json:"serviceAccountDistinguishedName,omitempty" norman:"required"`
	ServiceAccountPassword          string   `json:"serviceAccountPassword,omitempty"          norman:"type=password,required"`
	UserDisabledBitMask             int64    `json:"userDisabledBitMask,omitempty"`
	UserSearchBase                  string   `json:"userSearchBase,omitempty"                  norman:"notnullable,required"`
	UserSearchAttribute             string   `json:"userSearchAttribute,omitempty"             norman:"default=uid|sn|givenName,notnullable,required"`
	UserSearchFilter                string   `json:"userSearchFilter,omitempty"`
	UserLoginAttribute              string   `json:"userLoginAttribute,omitempty"              norman:"default=uid,notnullable,required"`
	UserObjectClass                 string   `json:"userObjectClass,omitempty"                 norman:"default=inetOrgPerson,notnullable,required"`
	UserNameAttribute               string   `json:"userNameAttribute,omitempty"               norman:"default=cn,notnullable,required"`
	UserMemberAttribute             string   `json:"userMemberAttribute,omitempty"             norman:"default=memberOf,notnullable,required"`
	UserEnabledAttribute            string   `json:"userEnabledAttribute,omitempty"`
	GroupSearchBase                 string   `json:"groupSearchBase,omitempty"`
	GroupSearchAttribute            string   `json:"groupSearchAttribute,omitempty"            norman:"default=cn,notnullable,required"`
	GroupSearchFilter               string   `json:"groupSearchFilter,omitempty"`
	GroupObjectClass                string   `json:"groupObjectClass,omitempty"                norman:"default=groupOfNames,notnullable,required"`
	GroupNameAttribute              string   `json:"groupNameAttribute,omitempty"              norman:"default=cn,notnullable,required"`
	GroupDNAttribute                string   `json:"groupDNAttribute,omitempty"                norman:"default=entryDN,notnullable"`
	GroupMemberUserAttribute        string   `json:"groupMemberUserAttribute,omitempty"        norman:"default=entryDN,notnullable"`
	GroupMemberMappingAttribute     string   `json:"groupMemberMappingAttribute,omitempty"     norman:"default=member,notnullable,required"`
	ConnectionTimeout               int64    `json:"connectionTimeout,omitempty"               norman:"default=5000,notnullable,required"`
	NestedGroupMembershipEnabled    bool     `json:"nestedGroupMembershipEnabled"              norman:"default=false"`
}

func (*LdapFields) DeepCopy 

func (in *LdapFields) DeepCopy() *LdapFields

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LdapFields.

func (*LdapFields) DeepCopyInto 

func (in *LdapFields) DeepCopyInto(out *LdapFields)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LdapTestAndApplyInput 

type LdapTestAndApplyInput struct {
	LdapConfig `json:"ldapConfig,omitempty"`
	Username   string `json:"username"`
	Password   string `json:"password" norman:"type=password,required"`
}

func (*LdapTestAndApplyInput) DeepCopy 

func (in *LdapTestAndApplyInput) DeepCopy() *LdapTestAndApplyInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LdapTestAndApplyInput.

func (*LdapTestAndApplyInput) DeepCopyInto 

func (in *LdapTestAndApplyInput) DeepCopyInto(out *LdapTestAndApplyInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*LdapTestAndApplyInput) DeepCopyObject 

func (in *LdapTestAndApplyInput) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type Limit 

type Limit struct {
	// type is the type of limit to which this configuration applies
	Type LimitType `json:"type"`

	// qps is the number of event queries per second that are allowed for this
	// type of limit. The qps and burst fields are used together to determine if
	// a particular event query is accepted. The qps determines how many queries
	// are accepted once the burst amount of queries has been exhausted.
	QPS int32 `json:"qps"`

	// burst is the burst number of event queries that are allowed for this type
	// of limit. The qps and burst fields are used together to determine if a
	// particular event query is accepted. The burst determines the maximum size
	// of the allowance granted for a particular bucket. For example, if the burst
	// is 10 and the qps is 3, then the admission control will accept 10 queries
	// before blocking any queries. Every second, 3 more queries will be allowed.
	// If some of that allowance is not used, then it will roll over to the next
	// second, until the maximum allowance of 10 is reached.
	Burst int32 `json:"burst"`

	// cacheSize is the size of the LRU cache for this type of limit. If a bucket
	// is evicted from the cache, then the allowance for that bucket is reset. If
	// more queries are later received for an evicted bucket, then that bucket
	// will re-enter the cache with a clean slate, giving that bucket a full
	// allowance of burst queries.
	//
	// The default cache size is 4096.
	//
	// If limitType is 'server', then cacheSize is ignored.
	// +optional
	CacheSize int32 `json:"cacheSize,omitempty"`
}

Limit is the configuration for a particular limit type

func (*Limit) DeepCopy 

func (in *Limit) DeepCopy() *Limit

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Limit.

func (*Limit) DeepCopyInto 

func (in *Limit) DeepCopyInto(out *Limit)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LimitType 

type LimitType string

LimitType is the type of the limit (e.g., per-namespace) 

const (
	// ServerLimitType is a type of limit where there is one bucket shared by
	// all of the event queries received by the API Server.
	ServerLimitType LimitType = "Server"
	// NamespaceLimitType is a type of limit where there is one bucket used by
	// each namespace
	NamespaceLimitType LimitType = "Namespace"
	// UserLimitType is a type of limit where there is one bucket used by each
	// user
	UserLimitType LimitType = "User"
	// SourceAndObjectLimitType is a type of limit where there is one bucket used
	// by each combination of source and involved object of the event.
	SourceAndObjectLimitType LimitType = "SourceAndObject"
)

type LinearAutoscalerParams 

type LinearAutoscalerParams struct {
	CoresPerReplica           float64 `yaml:"cores_per_replica" json:"coresPerReplica,omitempty" norman:"default=128"`
	NodesPerReplica           float64 `yaml:"nodes_per_replica" json:"nodesPerReplica,omitempty" norman:"default=4"`
	Min                       int     `yaml:"min" json:"min,omitempty" norman:"default=1"`
	Max                       int     `yaml:"max" json:"max,omitempty"`
	PreventSinglePointFailure bool    `yaml:"prevent_single_point_failure" json:"preventSinglePointFailure,omitempty" norman:"default=true"`
}

LinearAutoscalerParams contains fields expected by the cluster-proportional-autoscaler https://github.com/kubernetes-incubator/cluster-proportional-autoscaler/blob/0c61e63fc81449abdd52315aa27179a17e5d1580/pkg/autoscaler/controller/linearcontroller/linear_controller.go#L50

func (*LinearAutoscalerParams) DeepCopy 

func (in *LinearAutoscalerParams) DeepCopy() *LinearAutoscalerParams

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LinearAutoscalerParams.

func (*LinearAutoscalerParams) DeepCopyInto 

func (in *LinearAutoscalerParams) DeepCopyInto(out *LinearAutoscalerParams)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ListOpts 

type ListOpts struct {
	Filters map[string]string `json:"filters,omitempty"`
}

func (*ListOpts) DeepCopy 

func (in *ListOpts) DeepCopy() *ListOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ListOpts.

func (*ListOpts) DeepCopyInto 

func (in *ListOpts) DeepCopyInto(out *ListOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoadBalancerCapabilities 

type LoadBalancerCapabilities struct {
	Enabled              *bool    `json:"enabled,omitempty"`
	Provider             string   `json:"provider,omitempty"`
	ProtocolsSupported   []string `json:"protocolsSupported,omitempty"`
	HealthCheckSupported bool     `json:"healthCheckSupported,omitempty"`
}

func (*LoadBalancerCapabilities) DeepCopy 

func (in *LoadBalancerCapabilities) DeepCopy() *LoadBalancerCapabilities

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerCapabilities.

func (*LoadBalancerCapabilities) DeepCopyInto 

func (in *LoadBalancerCapabilities) DeepCopyInto(out *LoadBalancerCapabilities)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoadBalancerOpenstackOpts 

type LoadBalancerOpenstackOpts struct {
	LBVersion            string `json:"lb-version" yaml:"lb-version" ini:"lb-version,omitempty"`                            // overrides autodetection. Only support v2.
	UseOctavia           bool   `json:"use-octavia" yaml:"use-octavia" ini:"use-octavia,omitempty"`                         // uses Octavia V2 service catalog endpoint
	SubnetID             string `json:"subnet-id" yaml:"subnet-id" ini:"subnet-id,omitempty"`                               // overrides autodetection.
	FloatingNetworkID    string `json:"floating-network-id" yaml:"floating-network-id" ini:"floating-network-id,omitempty"` // If specified, will create floating ip for loadbalancer, or do not create floating ip.
	LBMethod             string `json:"lb-method" yaml:"lb-method" ini:"lb-method,omitempty"`                               // default to ROUND_ROBIN.
	LBProvider           string `json:"lb-provider" yaml:"lb-provider" ini:"lb-provider,omitempty"`
	CreateMonitor        bool   `json:"create-monitor" yaml:"create-monitor" ini:"create-monitor,omitempty"`
	MonitorDelay         string `json:"monitor-delay" yaml:"monitor-delay" ini:"monitor-delay,omitempty"`
	MonitorTimeout       string `json:"monitor-timeout" yaml:"monitor-timeout" ini:"monitor-timeout,omitempty"`
	MonitorMaxRetries    int    `json:"monitor-max-retries" yaml:"monitor-max-retries" ini:"monitor-max-retries,omitempty"`
	ManageSecurityGroups bool   `json:"manage-security-groups" yaml:"manage-security-groups" ini:"manage-security-groups,omitempty"`
}

func (*LoadBalancerOpenstackOpts) DeepCopy 

func (in *LoadBalancerOpenstackOpts) DeepCopy() *LoadBalancerOpenstackOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerOpenstackOpts.

func (*LoadBalancerOpenstackOpts) DeepCopyInto 

func (in *LoadBalancerOpenstackOpts) DeepCopyInto(out *LoadBalancerOpenstackOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LocalClusterAuthEndpoint 

type LocalClusterAuthEndpoint struct {
	Enabled bool   `json:"enabled"`
	FQDN    string `json:"fqdn,omitempty"`
	CACerts string `json:"caCerts,omitempty"`
}

func (*LocalClusterAuthEndpoint) DeepCopy 

func (in *LocalClusterAuthEndpoint) DeepCopy() *LocalClusterAuthEndpoint

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LocalClusterAuthEndpoint.

func (*LocalClusterAuthEndpoint) DeepCopyInto 

func (in *LocalClusterAuthEndpoint) DeepCopyInto(out *LocalClusterAuthEndpoint)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LocalConfig 

type LocalConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	AuthConfig        `json:",inline" mapstructure:",squash"`
}

func (*LocalConfig) DeepCopy 

func (in *LocalConfig) DeepCopy() *LocalConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LocalConfig.

func (*LocalConfig) DeepCopyInto 

func (in *LocalConfig) DeepCopyInto(out *LocalConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*LocalConfig) DeepCopyObject 

func (in *LocalConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type LoggingCommonField 

type LoggingCommonField struct {
	DisplayName         string            `json:"displayName,omitempty"`
	OutputFlushInterval int               `json:"outputFlushInterval,omitempty" norman:"default=60"`
	OutputTags          map[string]string `json:"outputTags,omitempty"`
	EnableJSONParsing   bool              `json:"enableJSONParsing,omitempty"`
}

func (*LoggingCommonField) DeepCopy 

func (in *LoggingCommonField) DeepCopy() *LoggingCommonField

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoggingCommonField.

func (*LoggingCommonField) DeepCopyInto 

func (in *LoggingCommonField) DeepCopyInto(out *LoggingCommonField)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoggingCondition 

type LoggingCondition struct {
	// Type of cluster condition.
	Type condition.Cond `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*LoggingCondition) DeepCopy 

func (in *LoggingCondition) DeepCopy() *LoggingCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoggingCondition.

func (*LoggingCondition) DeepCopyInto 

func (in *LoggingCondition) DeepCopyInto(out *LoggingCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoggingTargets 

type LoggingTargets struct {
	ElasticsearchConfig   *ElasticsearchConfig   `json:"elasticsearchConfig,omitempty"`
	SplunkConfig          *SplunkConfig          `json:"splunkConfig,omitempty"`
	KafkaConfig           *KafkaConfig           `json:"kafkaConfig,omitempty"`
	SyslogConfig          *SyslogConfig          `json:"syslogConfig,omitempty"`
	FluentForwarderConfig *FluentForwarderConfig `json:"fluentForwarderConfig,omitempty"`
	CustomTargetConfig    *CustomTargetConfig    `json:"customTargetConfig,omitempty"`
}

func (*LoggingTargets) DeepCopy 

func (in *LoggingTargets) DeepCopy() *LoggingTargets

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoggingTargets.

func (*LoggingTargets) DeepCopyInto 

func (in *LoggingTargets) DeepCopyInto(out *LoggingTargets)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MSTeamsConfig 

type MSTeamsConfig struct {
	URL string `json:"url,omitempty" norman:"required"`
	*HTTPClientConfig
}

func (*MSTeamsConfig) DeepCopy 

func (in *MSTeamsConfig) DeepCopy() *MSTeamsConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MSTeamsConfig.

func (*MSTeamsConfig) DeepCopyInto 

func (in *MSTeamsConfig) DeepCopyInto(out *MSTeamsConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MapDelta 

type MapDelta struct {
	Add    map[string]string `json:"add,omitempty"`
	Delete map[string]bool   `json:"delete,omitempty"`
}

func (*MapDelta) DeepCopy 

func (in *MapDelta) DeepCopy() *MapDelta

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MapDelta.

func (*MapDelta) DeepCopyInto 

func (in *MapDelta) DeepCopyInto(out *MapDelta)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MapStringInterface 

type MapStringInterface map[string]interface{}

func (*MapStringInterface) DeepCopy 

func (m *MapStringInterface) DeepCopy() *MapStringInterface

func (MapStringInterface) DeepCopyInto 

func (in MapStringInterface) DeepCopyInto(out *MapStringInterface)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Member 

type Member struct {
	UserName           string `json:"userName,omitempty" norman:"type=reference[user]"`
	UserPrincipalName  string `json:"userPrincipalName,omitempty" norman:"type=reference[principal]"`
	DisplayName        string `json:"displayName,omitempty"`
	GroupPrincipalName string `json:"groupPrincipalName,omitempty" norman:"type=reference[principal]"`
	AccessType         string `json:"accessType,omitempty" norman:"type=enum,options=owner|member|read-only"`
}

func (*Member) DeepCopy 

func (in *Member) DeepCopy() *Member

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Member.

func (*Member) DeepCopyInto 

func (in *Member) DeepCopyInto(out *Member)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MetadataOpenstackOpts 

type MetadataOpenstackOpts struct {
	SearchOrder    string `json:"search-order" yaml:"search-order" ini:"search-order,omitempty"`
	RequestTimeout int    `json:"request-timeout" yaml:"request-timeout" ini:"request-timeout,omitempty"`
}

func (*MetadataOpenstackOpts) DeepCopy 

func (in *MetadataOpenstackOpts) DeepCopy() *MetadataOpenstackOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetadataOpenstackOpts.

func (*MetadataOpenstackOpts) DeepCopyInto 

func (in *MetadataOpenstackOpts) DeepCopyInto(out *MetadataOpenstackOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MetadataUpdate 

type MetadataUpdate struct {
	Labels      MapDelta `json:"labels,omitempty"`
	Annotations MapDelta `json:"annotations,omitempty"`
}

func (*MetadataUpdate) DeepCopy 

func (in *MetadataUpdate) DeepCopy() *MetadataUpdate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetadataUpdate.

func (*MetadataUpdate) DeepCopyInto 

func (in *MetadataUpdate) DeepCopyInto(out *MetadataUpdate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MetricNamesOutput 

type MetricNamesOutput struct {
	Type  string   `json:"type,omitempty"`
	Names []string `json:"names" norman:"type=array[string]"`
}

func (*MetricNamesOutput) DeepCopy 

func (in *MetricNamesOutput) DeepCopy() *MetricNamesOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricNamesOutput.

func (*MetricNamesOutput) DeepCopyInto 

func (in *MetricNamesOutput) DeepCopyInto(out *MetricNamesOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MetricRule 

type MetricRule struct {
	Expression     string  `json:"expression,omitempty" norman:"required"`
	Description    string  `json:"description,omitempty"`
	Duration       string  `json:"duration,omitempty" norman:"required"`
	Comparison     string  `` /* 148-byte string literal not displayed */
	ThresholdValue float64 `json:"thresholdValue,omitempty" norman:"type=float"`
}

func (*MetricRule) DeepCopy 

func (in *MetricRule) DeepCopy() *MetricRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricRule.

func (*MetricRule) DeepCopyInto 

func (in *MetricRule) DeepCopyInto(out *MetricRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MonitorMetric 

type MonitorMetric struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec MonitorMetricSpec `json:"spec"`
}

func NewMonitorMetric 

func NewMonitorMetric(namespace, name string, obj MonitorMetric) *MonitorMetric

func (*MonitorMetric) DeepCopy 

func (in *MonitorMetric) DeepCopy() *MonitorMetric

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitorMetric.

func (*MonitorMetric) DeepCopyInto 

func (in *MonitorMetric) DeepCopyInto(out *MonitorMetric)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MonitorMetric) DeepCopyObject 

func (in *MonitorMetric) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MonitorMetricChangeHandlerFunc 

type MonitorMetricChangeHandlerFunc func(obj *MonitorMetric) (runtime.Object, error)

type MonitorMetricController 

type MonitorMetricController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() MonitorMetricLister
	AddHandler(ctx context.Context, name string, handler MonitorMetricHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync MonitorMetricHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler MonitorMetricHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler MonitorMetricHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type MonitorMetricHandlerFunc 

type MonitorMetricHandlerFunc func(key string, obj *MonitorMetric) (runtime.Object, error)

func NewMonitorMetricLifecycleAdapter 

func NewMonitorMetricLifecycleAdapter(name string, clusterScoped bool, client MonitorMetricInterface, l MonitorMetricLifecycle) MonitorMetricHandlerFunc

type MonitorMetricInterface 

type MonitorMetricInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*MonitorMetric) (*MonitorMetric, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*MonitorMetric, error)
	Get(name string, opts metav1.GetOptions) (*MonitorMetric, error)
	Update(*MonitorMetric) (*MonitorMetric, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*MonitorMetricList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*MonitorMetricList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() MonitorMetricController
	AddHandler(ctx context.Context, name string, sync MonitorMetricHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync MonitorMetricHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle MonitorMetricLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle MonitorMetricLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync MonitorMetricHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync MonitorMetricHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle MonitorMetricLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle MonitorMetricLifecycle)
}

type MonitorMetricLifecycle 

type MonitorMetricLifecycle interface {
	Create(obj *MonitorMetric) (runtime.Object, error)
	Remove(obj *MonitorMetric) (runtime.Object, error)
	Updated(obj *MonitorMetric) (runtime.Object, error)
}

type MonitorMetricList 

type MonitorMetricList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []MonitorMetric `json:"items"`
}

func (*MonitorMetricList) DeepCopy 

func (in *MonitorMetricList) DeepCopy() *MonitorMetricList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitorMetricList.

func (*MonitorMetricList) DeepCopyInto 

func (in *MonitorMetricList) DeepCopyInto(out *MonitorMetricList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MonitorMetricList) DeepCopyObject 

func (in *MonitorMetricList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MonitorMetricLister 

type MonitorMetricLister interface {
	List(namespace string, selector labels.Selector) (ret []*MonitorMetric, err error)
	Get(namespace, name string) (*MonitorMetric, error)
}

type MonitorMetricSpec 

type MonitorMetricSpec struct {
	Expression   string `json:"expression,omitempty" norman:"required"`
	LegendFormat string `json:"legendFormat,omitempty"`
	Description  string `json:"description,omitempty"`
}

func (*MonitorMetricSpec) DeepCopy 

func (in *MonitorMetricSpec) DeepCopy() *MonitorMetricSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitorMetricSpec.

func (*MonitorMetricSpec) DeepCopyInto 

func (in *MonitorMetricSpec) DeepCopyInto(out *MonitorMetricSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MonitorMetricsGetter 

type MonitorMetricsGetter interface {
	MonitorMetrics(namespace string) MonitorMetricInterface
}

type MonitoringCondition 

type MonitoringCondition struct {
	// Type of cluster condition.
	Type ClusterConditionType `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*MonitoringCondition) DeepCopy 

func (in *MonitoringCondition) DeepCopy() *MonitoringCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitoringCondition.

func (*MonitoringCondition) DeepCopyInto 

func (in *MonitoringCondition) DeepCopyInto(out *MonitoringCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MonitoringConfig 

type MonitoringConfig struct {
	// Monitoring server provider
	Provider string `yaml:"provider" json:"provider,omitempty" norman:"default=metrics-server"`
	// Metrics server options
	Options map[string]string `yaml:"options" json:"options,omitempty"`
	// NodeSelector key pair
	NodeSelector map[string]string `yaml:"node_selector" json:"nodeSelector,omitempty"`
	// Update strategy
	UpdateStrategy *DeploymentStrategy `yaml:"update_strategy" json:"updateStrategy,omitempty"`
	// Number of monitoring addon pods
	Replicas *int32 `yaml:"replicas" json:"replicas,omitempty" norman:"default=1"`
	// Tolerations for Deployments
	Tolerations []v1.Toleration `yaml:"tolerations" json:"tolerations,omitempty"`
}

func (*MonitoringConfig) DeepCopy 

func (in *MonitoringConfig) DeepCopy() *MonitoringConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitoringConfig.

func (*MonitoringConfig) DeepCopyInto 

func (in *MonitoringConfig) DeepCopyInto(out *MonitoringConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MonitoringInput 

type MonitoringInput struct {
	Version string            `json:"version,omitempty"`
	Answers map[string]string `json:"answers,omitempty"`
}

func (*MonitoringInput) DeepCopy 

func (in *MonitoringInput) DeepCopy() *MonitoringInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitoringInput.

func (*MonitoringInput) DeepCopyInto 

func (in *MonitoringInput) DeepCopyInto(out *MonitoringInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MonitoringOutput 

type MonitoringOutput struct {
	Version string            `json:"version,omitempty"`
	Answers map[string]string `json:"answers,omitempty"`
}

func (*MonitoringOutput) DeepCopy 

func (in *MonitoringOutput) DeepCopy() *MonitoringOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitoringOutput.

func (*MonitoringOutput) DeepCopyInto 

func (in *MonitoringOutput) DeepCopyInto(out *MonitoringOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MonitoringStatus 

type MonitoringStatus struct {
	GrafanaEndpoint string                `json:"grafanaEndpoint,omitempty"`
	Conditions      []MonitoringCondition `json:"conditions,omitempty"`
}

func (*MonitoringStatus) DeepCopy 

func (in *MonitoringStatus) DeepCopy() *MonitoringStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MonitoringStatus.

func (*MonitoringStatus) DeepCopyInto 

func (in *MonitoringStatus) DeepCopyInto(out *MonitoringStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MultiClusterApp 

type MultiClusterApp struct {
	types.Namespaced
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   MultiClusterAppSpec   `json:"spec"`
	Status MultiClusterAppStatus `json:"status"`
}

func NewMultiClusterApp 

func NewMultiClusterApp(namespace, name string, obj MultiClusterApp) *MultiClusterApp

func (*MultiClusterApp) DeepCopy 

func (in *MultiClusterApp) DeepCopy() *MultiClusterApp

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MultiClusterApp.

func (*MultiClusterApp) DeepCopyInto 

func (in *MultiClusterApp) DeepCopyInto(out *MultiClusterApp)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MultiClusterApp) DeepCopyObject 

func (in *MultiClusterApp) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MultiClusterAppChangeHandlerFunc 

type MultiClusterAppChangeHandlerFunc func(obj *MultiClusterApp) (runtime.Object, error)

type MultiClusterAppController 

type MultiClusterAppController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() MultiClusterAppLister
	AddHandler(ctx context.Context, name string, handler MultiClusterAppHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync MultiClusterAppHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler MultiClusterAppHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler MultiClusterAppHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type MultiClusterAppHandlerFunc 

type MultiClusterAppHandlerFunc func(key string, obj *MultiClusterApp) (runtime.Object, error)

func NewMultiClusterAppLifecycleAdapter 

func NewMultiClusterAppLifecycleAdapter(name string, clusterScoped bool, client MultiClusterAppInterface, l MultiClusterAppLifecycle) MultiClusterAppHandlerFunc

type MultiClusterAppInterface 

type MultiClusterAppInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*MultiClusterApp) (*MultiClusterApp, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*MultiClusterApp, error)
	Get(name string, opts metav1.GetOptions) (*MultiClusterApp, error)
	Update(*MultiClusterApp) (*MultiClusterApp, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*MultiClusterAppList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*MultiClusterAppList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() MultiClusterAppController
	AddHandler(ctx context.Context, name string, sync MultiClusterAppHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync MultiClusterAppHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle MultiClusterAppLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle MultiClusterAppLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync MultiClusterAppHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync MultiClusterAppHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle MultiClusterAppLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle MultiClusterAppLifecycle)
}

type MultiClusterAppLifecycle 

type MultiClusterAppLifecycle interface {
	Create(obj *MultiClusterApp) (runtime.Object, error)
	Remove(obj *MultiClusterApp) (runtime.Object, error)
	Updated(obj *MultiClusterApp) (runtime.Object, error)
}

type MultiClusterAppList 

type MultiClusterAppList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []MultiClusterApp `json:"items"`
}

func (*MultiClusterAppList) DeepCopy 

func (in *MultiClusterAppList) DeepCopy() *MultiClusterAppList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MultiClusterAppList.

func (*MultiClusterAppList) DeepCopyInto 

func (in *MultiClusterAppList) DeepCopyInto(out *MultiClusterAppList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MultiClusterAppList) DeepCopyObject 

func (in *MultiClusterAppList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MultiClusterAppLister 

type MultiClusterAppLister interface {
	List(namespace string, selector labels.Selector) (ret []*MultiClusterApp, err error)
	Get(namespace, name string) (*MultiClusterApp, error)
}

type MultiClusterAppRevision 

type MultiClusterAppRevision struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	TemplateVersionName string   `json:"templateVersionName,omitempty" norman:"type=reference[templateVersion]"`
	Answers             []Answer `json:"answers,omitempty"`
}

func NewMultiClusterAppRevision 

func NewMultiClusterAppRevision(namespace, name string, obj MultiClusterAppRevision) *MultiClusterAppRevision

func (*MultiClusterAppRevision) DeepCopy 

func (in *MultiClusterAppRevision) DeepCopy() *MultiClusterAppRevision

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MultiClusterAppRevision.

func (*MultiClusterAppRevision) DeepCopyInto 

func (in *MultiClusterAppRevision) DeepCopyInto(out *MultiClusterAppRevision)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MultiClusterAppRevision) DeepCopyObject 

func (in *MultiClusterAppRevision) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MultiClusterAppRevisionChangeHandlerFunc 

type MultiClusterAppRevisionChangeHandlerFunc func(obj *MultiClusterAppRevision) (runtime.Object, error)

type MultiClusterAppRevisionController 

type MultiClusterAppRevisionController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() MultiClusterAppRevisionLister
	AddHandler(ctx context.Context, name string, handler MultiClusterAppRevisionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync MultiClusterAppRevisionHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler MultiClusterAppRevisionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler MultiClusterAppRevisionHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type MultiClusterAppRevisionHandlerFunc 

type MultiClusterAppRevisionHandlerFunc func(key string, obj *MultiClusterAppRevision) (runtime.Object, error)

func NewMultiClusterAppRevisionLifecycleAdapter 

func NewMultiClusterAppRevisionLifecycleAdapter(name string, clusterScoped bool, client MultiClusterAppRevisionInterface, l MultiClusterAppRevisionLifecycle) MultiClusterAppRevisionHandlerFunc

type MultiClusterAppRevisionInterface 

type MultiClusterAppRevisionInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*MultiClusterAppRevision) (*MultiClusterAppRevision, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*MultiClusterAppRevision, error)
	Get(name string, opts metav1.GetOptions) (*MultiClusterAppRevision, error)
	Update(*MultiClusterAppRevision) (*MultiClusterAppRevision, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*MultiClusterAppRevisionList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*MultiClusterAppRevisionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() MultiClusterAppRevisionController
	AddHandler(ctx context.Context, name string, sync MultiClusterAppRevisionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync MultiClusterAppRevisionHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle MultiClusterAppRevisionLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle MultiClusterAppRevisionLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync MultiClusterAppRevisionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync MultiClusterAppRevisionHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle MultiClusterAppRevisionLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle MultiClusterAppRevisionLifecycle)
}

type MultiClusterAppRevisionLifecycle 

type MultiClusterAppRevisionLifecycle interface {
	Create(obj *MultiClusterAppRevision) (runtime.Object, error)
	Remove(obj *MultiClusterAppRevision) (runtime.Object, error)
	Updated(obj *MultiClusterAppRevision) (runtime.Object, error)
}

type MultiClusterAppRevisionList 

type MultiClusterAppRevisionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []MultiClusterAppRevision `json:"items"`
}

func (*MultiClusterAppRevisionList) DeepCopy 

func (in *MultiClusterAppRevisionList) DeepCopy() *MultiClusterAppRevisionList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MultiClusterAppRevisionList.

func (*MultiClusterAppRevisionList) DeepCopyInto 

func (in *MultiClusterAppRevisionList) DeepCopyInto(out *MultiClusterAppRevisionList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MultiClusterAppRevisionList) DeepCopyObject 

func (in *MultiClusterAppRevisionList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MultiClusterAppRevisionLister 

type MultiClusterAppRevisionLister interface {
	List(namespace string, selector labels.Selector) (ret []*MultiClusterAppRevision, err error)
	Get(namespace, name string) (*MultiClusterAppRevision, error)
}

type MultiClusterAppRevisionsGetter 

type MultiClusterAppRevisionsGetter interface {
	MultiClusterAppRevisions(namespace string) MultiClusterAppRevisionInterface
}

type MultiClusterAppRollbackInput 

type MultiClusterAppRollbackInput struct {
	RevisionName string `json:"revisionName,omitempty" norman:"type=reference[multiClusterAppRevision]"`
}

func (*MultiClusterAppRollbackInput) DeepCopy 

func (in *MultiClusterAppRollbackInput) DeepCopy() *MultiClusterAppRollbackInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MultiClusterAppRollbackInput.

func (*MultiClusterAppRollbackInput) DeepCopyInto 

func (in *MultiClusterAppRollbackInput) DeepCopyInto(out *MultiClusterAppRollbackInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MultiClusterAppSpec 

type MultiClusterAppSpec struct {
	TemplateVersionName  string          `json:"templateVersionName,omitempty" norman:"type=reference[templateVersion],required"`
	Answers              []Answer        `json:"answers,omitempty"`
	Wait                 bool            `json:"wait,omitempty"`
	Timeout              int             `json:"timeout,omitempty" norman:"min=1,default=300"`
	Targets              []Target        `json:"targets,omitempty" norman:"required,noupdate"`
	Members              []Member        `json:"members,omitempty"`
	Roles                []string        `json:"roles,omitempty" norman:"type=array[reference[roleTemplate]],required"`
	RevisionHistoryLimit int             `json:"revisionHistoryLimit,omitempty" norman:"default=10"`
	UpgradeStrategy      UpgradeStrategy `json:"upgradeStrategy,omitempty"`
}

func (*MultiClusterAppSpec) DeepCopy 

func (in *MultiClusterAppSpec) DeepCopy() *MultiClusterAppSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MultiClusterAppSpec.

func (*MultiClusterAppSpec) DeepCopyInto 

func (in *MultiClusterAppSpec) DeepCopyInto(out *MultiClusterAppSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MultiClusterAppStatus 

type MultiClusterAppStatus struct {
	Conditions   []v3.AppCondition `json:"conditions,omitempty"`
	RevisionName string            `json:"revisionName,omitempty" norman:"type=reference[multiClusterAppRevision],required"`
	HelmVersion  string            `json:"helmVersion,omitempty" norman:"nocreate,noupdate"`
}

func (*MultiClusterAppStatus) DeepCopy 

func (in *MultiClusterAppStatus) DeepCopy() *MultiClusterAppStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MultiClusterAppStatus.

func (*MultiClusterAppStatus) DeepCopyInto 

func (in *MultiClusterAppStatus) DeepCopyInto(out *MultiClusterAppStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MultiClusterAppsGetter 

type MultiClusterAppsGetter interface {
	MultiClusterApps(namespace string) MultiClusterAppInterface
}

type NamespaceResourceQuota 

type NamespaceResourceQuota struct {
	Limit ResourceQuotaLimit `json:"limit,omitempty"`
}

func (*NamespaceResourceQuota) DeepCopy 

func (in *NamespaceResourceQuota) DeepCopy() *NamespaceResourceQuota

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceResourceQuota.

func (*NamespaceResourceQuota) DeepCopyInto 

func (in *NamespaceResourceQuota) DeepCopyInto(out *NamespaceResourceQuota)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NetworkConfig 

type NetworkConfig struct {
	// Network Plugin That will be used in kubernetes cluster
	Plugin string `yaml:"plugin" json:"plugin,omitempty" norman:"default=canal"`
	// Plugin options to configure network properties
	Options map[string]string `yaml:"options" json:"options,omitempty"`
	// Set MTU for CNI provider
	MTU int `yaml:"mtu" json:"mtu,omitempty"`
	// CalicoNetworkProvider
	CalicoNetworkProvider *CalicoNetworkProvider `yaml:"calico_network_provider,omitempty" json:"calicoNetworkProvider,omitempty"`
	// CanalNetworkProvider
	CanalNetworkProvider *CanalNetworkProvider `yaml:"canal_network_provider,omitempty" json:"canalNetworkProvider,omitempty"`
	// FlannelNetworkProvider
	FlannelNetworkProvider *FlannelNetworkProvider `yaml:"flannel_network_provider,omitempty" json:"flannelNetworkProvider,omitempty"`
	// WeaveNetworkProvider
	WeaveNetworkProvider *WeaveNetworkProvider `yaml:"weave_network_provider,omitempty" json:"weaveNetworkProvider,omitempty"`
	// NodeSelector key pair
	NodeSelector map[string]string `yaml:"node_selector" json:"nodeSelector,omitempty"`
	// Network plugin daemonset upgrade strategy
	UpdateStrategy *DaemonSetUpdateStrategy `yaml:"update_strategy" json:"updateStrategy,omitempty"`
	// Tolerations for Deployments
	Tolerations []v1.Toleration `yaml:"tolerations" json:"tolerations,omitempty"`
}

func (*NetworkConfig) DeepCopy 

func (in *NetworkConfig) DeepCopy() *NetworkConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkConfig.

func (*NetworkConfig) DeepCopyInto 

func (in *NetworkConfig) DeepCopyInto(out *NetworkConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NetworkVshpereOpts 

type NetworkVshpereOpts struct {
	PublicNetwork string `json:"public-network,omitempty" yaml:"public-network,omitempty" ini:"public-network,omitempty"`
}

func (*NetworkVshpereOpts) DeepCopy 

func (in *NetworkVshpereOpts) DeepCopy() *NetworkVshpereOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkVshpereOpts.

func (*NetworkVshpereOpts) DeepCopyInto 

func (in *NetworkVshpereOpts) DeepCopyInto(out *NetworkVshpereOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Node 

type Node struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec NodeSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status NodeStatus `json:"status"`
}

func NewNode 

func NewNode(namespace, name string, obj Node) *Node

func (*Node) DeepCopy 

func (in *Node) DeepCopy() *Node

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Node.

func (*Node) DeepCopyInto 

func (in *Node) DeepCopyInto(out *Node)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Node) DeepCopyObject 

func (in *Node) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*Node) ObjClusterName 

func (in *Node) ObjClusterName() string

type NodeChangeHandlerFunc 

type NodeChangeHandlerFunc func(obj *Node) (runtime.Object, error)

type NodeCommonParams 

type NodeCommonParams struct {
	AuthCertificateAuthority string            `json:"authCertificateAuthority,omitempty"`
	AuthKey                  string            `json:"authKey,omitempty"`
	EngineInstallURL         string            `json:"engineInstallURL,omitempty"`
	DockerVersion            string            `json:"dockerVersion,omitempty"`
	EngineOpt                map[string]string `json:"engineOpt,omitempty"`
	EngineInsecureRegistry   []string          `json:"engineInsecureRegistry,omitempty"`
	EngineRegistryMirror     []string          `json:"engineRegistryMirror,omitempty"`
	EngineLabel              map[string]string `json:"engineLabel,omitempty"`
	EngineStorageDriver      string            `json:"engineStorageDriver,omitempty"`
	EngineEnv                map[string]string `json:"engineEnv,omitempty"`
	UseInternalIPAddress     *bool             `json:"useInternalIpAddress,omitempty" norman:"default=true,noupdate"`
}

func (*NodeCommonParams) DeepCopy 

func (in *NodeCommonParams) DeepCopy() *NodeCommonParams

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeCommonParams.

func (*NodeCommonParams) DeepCopyInto 

func (in *NodeCommonParams) DeepCopyInto(out *NodeCommonParams)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeCondition 

type NodeCondition struct {
	// Type of cluster condition.
	Type condition.Cond `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*NodeCondition) DeepCopy 

func (in *NodeCondition) DeepCopy() *NodeCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeCondition.

func (*NodeCondition) DeepCopyInto 

func (in *NodeCondition) DeepCopyInto(out *NodeCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeController 

type NodeController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() NodeLister
	AddHandler(ctx context.Context, name string, handler NodeHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodeHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler NodeHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type NodeDrainInput 

type NodeDrainInput struct {
	// Drain node even if there are pods not managed by a ReplicationController, Job, or DaemonSet
	// Drain will not proceed without Force set to true if there are such pods
	Force bool `yaml:"force" json:"force,omitempty"`
	// If there are DaemonSet-managed pods, drain will not proceed without IgnoreDaemonSets set to true
	// (even when set to true, kubectl won't delete pods - so setting default to true)
	IgnoreDaemonSets *bool `yaml:"ignore_daemonsets" json:"ignoreDaemonSets,omitempty" norman:"default=true"`
	// Continue even if there are pods using emptyDir
	DeleteLocalData bool `yaml:"delete_local_data" json:"deleteLocalData,omitempty"`
	//Period of time in seconds given to each pod to terminate gracefully.
	// If negative, the default value specified in the pod will be used
	GracePeriod int `yaml:"grace_period" json:"gracePeriod,omitempty" norman:"default=-1"`
	// Time to wait (in seconds) before giving up for one try
	Timeout int `yaml:"timeout" json:"timeout" norman:"min=1,max=10800,default=120"`
}

func (*NodeDrainInput) DeepCopy 

func (in *NodeDrainInput) DeepCopy() *NodeDrainInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeDrainInput.

func (*NodeDrainInput) DeepCopyInto 

func (in *NodeDrainInput) DeepCopyInto(out *NodeDrainInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeDriver 

type NodeDriver struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec NodeDriverSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status NodeDriverStatus `json:"status"`
}

func NewNodeDriver 

func NewNodeDriver(namespace, name string, obj NodeDriver) *NodeDriver

func (*NodeDriver) DeepCopy 

func (in *NodeDriver) DeepCopy() *NodeDriver

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeDriver.

func (*NodeDriver) DeepCopyInto 

func (in *NodeDriver) DeepCopyInto(out *NodeDriver)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodeDriver) DeepCopyObject 

func (in *NodeDriver) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type NodeDriverChangeHandlerFunc 

type NodeDriverChangeHandlerFunc func(obj *NodeDriver) (runtime.Object, error)

type NodeDriverController 

type NodeDriverController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() NodeDriverLister
	AddHandler(ctx context.Context, name string, handler NodeDriverHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodeDriverHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeDriverHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler NodeDriverHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type NodeDriverHandlerFunc 

type NodeDriverHandlerFunc func(key string, obj *NodeDriver) (runtime.Object, error)

func NewNodeDriverLifecycleAdapter 

func NewNodeDriverLifecycleAdapter(name string, clusterScoped bool, client NodeDriverInterface, l NodeDriverLifecycle) NodeDriverHandlerFunc

type NodeDriverInterface 

type NodeDriverInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*NodeDriver) (*NodeDriver, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*NodeDriver, error)
	Get(name string, opts metav1.GetOptions) (*NodeDriver, error)
	Update(*NodeDriver) (*NodeDriver, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*NodeDriverList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*NodeDriverList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() NodeDriverController
	AddHandler(ctx context.Context, name string, sync NodeDriverHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodeDriverHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle NodeDriverLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle NodeDriverLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeDriverHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync NodeDriverHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeDriverLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle NodeDriverLifecycle)
}

type NodeDriverLifecycle 

type NodeDriverLifecycle interface {
	Create(obj *NodeDriver) (runtime.Object, error)
	Remove(obj *NodeDriver) (runtime.Object, error)
	Updated(obj *NodeDriver) (runtime.Object, error)
}

type NodeDriverList 

type NodeDriverList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NodeDriver `json:"items"`
}

func (*NodeDriverList) DeepCopy 

func (in *NodeDriverList) DeepCopy() *NodeDriverList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeDriverList.

func (*NodeDriverList) DeepCopyInto 

func (in *NodeDriverList) DeepCopyInto(out *NodeDriverList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodeDriverList) DeepCopyObject 

func (in *NodeDriverList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type NodeDriverLister 

type NodeDriverLister interface {
	List(namespace string, selector labels.Selector) (ret []*NodeDriver, err error)
	Get(namespace, name string) (*NodeDriver, error)
}

type NodeDriverSpec 

type NodeDriverSpec struct {
	DisplayName      string   `json:"displayName"`
	Description      string   `json:"description"`
	URL              string   `json:"url" norman:"required"`
	ExternalID       string   `json:"externalId"`
	Builtin          bool     `json:"builtin"`
	Active           bool     `json:"active"`
	Checksum         string   `json:"checksum"`
	UIURL            string   `json:"uiUrl"`
	WhitelistDomains []string `json:"whitelistDomains,omitempty"`
}

func (*NodeDriverSpec) DeepCopy 

func (in *NodeDriverSpec) DeepCopy() *NodeDriverSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeDriverSpec.

func (*NodeDriverSpec) DeepCopyInto 

func (in *NodeDriverSpec) DeepCopyInto(out *NodeDriverSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeDriverStatus 

type NodeDriverStatus struct {
	Conditions                  []Condition `json:"conditions"`
	AppliedURL                  string      `json:"appliedURL"`
	AppliedChecksum             string      `json:"appliedChecksum"`
	AppliedDockerMachineVersion string      `json:"appliedDockerMachineVersion"`
}

func (*NodeDriverStatus) DeepCopy 

func (in *NodeDriverStatus) DeepCopy() *NodeDriverStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeDriverStatus.

func (*NodeDriverStatus) DeepCopyInto 

func (in *NodeDriverStatus) DeepCopyInto(out *NodeDriverStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeDriversGetter 

type NodeDriversGetter interface {
	NodeDrivers(namespace string) NodeDriverInterface
}

type NodeHandlerFunc 

type NodeHandlerFunc func(key string, obj *Node) (runtime.Object, error)

func NewNodeLifecycleAdapter 

func NewNodeLifecycleAdapter(name string, clusterScoped bool, client NodeInterface, l NodeLifecycle) NodeHandlerFunc

type NodeInterface 

type NodeInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Node) (*Node, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Node, error)
	Get(name string, opts metav1.GetOptions) (*Node, error)
	Update(*Node) (*Node, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*NodeList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*NodeList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() NodeController
	AddHandler(ctx context.Context, name string, sync NodeHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodeHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle NodeLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle NodeLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync NodeHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle NodeLifecycle)
}

type NodeLifecycle 

type NodeLifecycle interface {
	Create(obj *Node) (runtime.Object, error)
	Remove(obj *Node) (runtime.Object, error)
	Updated(obj *Node) (runtime.Object, error)
}

type NodeList 

type NodeList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Node `json:"items"`
}

func (*NodeList) DeepCopy 

func (in *NodeList) DeepCopy() *NodeList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeList.

func (*NodeList) DeepCopyInto 

func (in *NodeList) DeepCopyInto(out *NodeList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodeList) DeepCopyObject 

func (in *NodeList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type NodeLister 

type NodeLister interface {
	List(namespace string, selector labels.Selector) (ret []*Node, err error)
	Get(namespace, name string) (*Node, error)
}

type NodePlan 

type NodePlan struct {
	Plan    *RKEConfigNodePlan `json:"plan,omitempty"`
	Version int                `json:"version,omitempty"`
	// current default in rancher-agent is 2m (120s)
	AgentCheckInterval int `json:"agentCheckInterval,omitempty" norman:"min=1,max=1800,default=120"`
}

func (*NodePlan) DeepCopy 

func (in *NodePlan) DeepCopy() *NodePlan

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodePlan.

func (*NodePlan) DeepCopyInto 

func (in *NodePlan) DeepCopyInto(out *NodePlan)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodePool 

type NodePool struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   NodePoolSpec   `json:"spec"`
	Status NodePoolStatus `json:"status"`
}

func NewNodePool 

func NewNodePool(namespace, name string, obj NodePool) *NodePool

func (*NodePool) DeepCopy 

func (in *NodePool) DeepCopy() *NodePool

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodePool.

func (*NodePool) DeepCopyInto 

func (in *NodePool) DeepCopyInto(out *NodePool)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodePool) DeepCopyObject 

func (in *NodePool) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*NodePool) ObjClusterName 

func (n *NodePool) ObjClusterName() string

type NodePoolChangeHandlerFunc 

type NodePoolChangeHandlerFunc func(obj *NodePool) (runtime.Object, error)

type NodePoolController 

type NodePoolController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() NodePoolLister
	AddHandler(ctx context.Context, name string, handler NodePoolHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodePoolHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodePoolHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler NodePoolHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type NodePoolHandlerFunc 

type NodePoolHandlerFunc func(key string, obj *NodePool) (runtime.Object, error)

func NewNodePoolLifecycleAdapter 

func NewNodePoolLifecycleAdapter(name string, clusterScoped bool, client NodePoolInterface, l NodePoolLifecycle) NodePoolHandlerFunc

type NodePoolInterface 

type NodePoolInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*NodePool) (*NodePool, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*NodePool, error)
	Get(name string, opts metav1.GetOptions) (*NodePool, error)
	Update(*NodePool) (*NodePool, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*NodePoolList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*NodePoolList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() NodePoolController
	AddHandler(ctx context.Context, name string, sync NodePoolHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodePoolHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle NodePoolLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle NodePoolLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodePoolHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync NodePoolHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodePoolLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle NodePoolLifecycle)
}

type NodePoolLifecycle 

type NodePoolLifecycle interface {
	Create(obj *NodePool) (runtime.Object, error)
	Remove(obj *NodePool) (runtime.Object, error)
	Updated(obj *NodePool) (runtime.Object, error)
}

type NodePoolList 

type NodePoolList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NodePool `json:"items"`
}

func (*NodePoolList) DeepCopy 

func (in *NodePoolList) DeepCopy() *NodePoolList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodePoolList.

func (*NodePoolList) DeepCopyInto 

func (in *NodePoolList) DeepCopyInto(out *NodePoolList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodePoolList) DeepCopyObject 

func (in *NodePoolList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type NodePoolLister 

type NodePoolLister interface {
	List(namespace string, selector labels.Selector) (ret []*NodePool, err error)
	Get(namespace, name string) (*NodePool, error)
}

type NodePoolSpec 

type NodePoolSpec struct {
	Etcd             bool   `json:"etcd"`
	ControlPlane     bool   `json:"controlPlane"`
	Worker           bool   `json:"worker"`
	NodeTemplateName string `json:"nodeTemplateName,omitempty" norman:"type=reference[nodeTemplate],required,notnullable"`

	HostnamePrefix  string            `json:"hostnamePrefix" norman:"required,notnullable"`
	Quantity        int               `json:"quantity" norman:"required,default=1"`
	NodeLabels      map[string]string `json:"nodeLabels"`
	NodeAnnotations map[string]string `json:"nodeAnnotations"`
	NodeTaints      []v1.Taint        `json:"nodeTaints,omitempty"`

	DisplayName string `json:"displayName"`
	ClusterName string `json:"clusterName,omitempty" norman:"type=reference[cluster],noupdate,required"`

	DeleteNotReadyAfterSecs time.Duration `json:"deleteNotReadyAfterSecs" norman:"default=0,max=31540000,min=0"`
}

func (*NodePoolSpec) DeepCopy 

func (in *NodePoolSpec) DeepCopy() *NodePoolSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodePoolSpec.

func (*NodePoolSpec) DeepCopyInto 

func (in *NodePoolSpec) DeepCopyInto(out *NodePoolSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodePoolSpec) ObjClusterName 

func (n *NodePoolSpec) ObjClusterName() string

type NodePoolStatus 

type NodePoolStatus struct {
	Conditions []Condition `json:"conditions"`
}

func (*NodePoolStatus) DeepCopy 

func (in *NodePoolStatus) DeepCopy() *NodePoolStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodePoolStatus.

func (*NodePoolStatus) DeepCopyInto 

func (in *NodePoolStatus) DeepCopyInto(out *NodePoolStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodePoolsGetter 

type NodePoolsGetter interface {
	NodePools(namespace string) NodePoolInterface
}

type NodeRule 

type NodeRule struct {
	NodeName     string            `json:"nodeName,omitempty" norman:"type=reference[node]"`
	Selector     map[string]string `json:"selector,omitempty"`
	Condition    string            `json:"condition,omitempty" norman:"required,options=notready|mem|cpu,default=notready"`
	MemThreshold int               `json:"memThreshold,omitempty" norman:"min=1,max=100,default=70"`
	CPUThreshold int               `json:"cpuThreshold,omitempty" norman:"min=1,default=70"`
}

func (*NodeRule) DeepCopy 

func (in *NodeRule) DeepCopy() *NodeRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeRule.

func (*NodeRule) DeepCopyInto 

func (in *NodeRule) DeepCopyInto(out *NodeRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeSpec 

type NodeSpec struct {
	Etcd             bool   `json:"etcd" norman:"noupdate"`
	ControlPlane     bool   `json:"controlPlane" norman:"noupdate"`
	Worker           bool   `json:"worker" norman:"noupdate"`
	NodeTemplateName string `json:"nodeTemplateName,omitempty" norman:"type=reference[nodeTemplate],noupdate"`

	NodePoolName             string          `json:"nodePoolName" norman:"type=reference[nodePool],nocreate,noupdate"`
	CustomConfig             *CustomConfig   `json:"customConfig"`
	Imported                 bool            `json:"imported"`
	Description              string          `json:"description,omitempty"`
	DisplayName              string          `json:"displayName"`
	RequestedHostname        string          `json:"requestedHostname,omitempty" norman:"type=hostname,nullable,noupdate,required"`
	InternalNodeSpec         v1.NodeSpec     `json:"internalNodeSpec"`
	DesiredNodeTaints        []v1.Taint      `json:"desiredNodeTaints"`
	UpdateTaintsFromAPI      *bool           `json:"updateTaintsFromAPI,omitempty"`
	DesiredNodeUnschedulable string          `json:"desiredNodeUnschedulable,omitempty"`
	NodeDrainInput           *NodeDrainInput `json:"nodeDrainInput,omitempty"`
	MetadataUpdate           MetadataUpdate  `json:"metadataUpdate,omitempty"`
}

func (*NodeSpec) DeepCopy 

func (in *NodeSpec) DeepCopy() *NodeSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeSpec.

func (*NodeSpec) DeepCopyInto 

func (in *NodeSpec) DeepCopyInto(out *NodeSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeStatus 

type NodeStatus struct {
	Conditions         []NodeCondition   `json:"conditions,omitempty"`
	InternalNodeStatus v1.NodeStatus     `json:"internalNodeStatus,omitempty"`
	NodeName           string            `json:"nodeName,omitempty"`
	Requested          v1.ResourceList   `json:"requested,omitempty"`
	Limits             v1.ResourceList   `json:"limits,omitempty"`
	NodeTemplateSpec   *NodeTemplateSpec `json:"nodeTemplateSpec,omitempty"`
	NodeConfig         *RKEConfigNode    `json:"rkeNode,omitempty"`
	NodeAnnotations    map[string]string `json:"nodeAnnotations,omitempty"`
	NodeLabels         map[string]string `json:"nodeLabels,omitempty"`
	NodeTaints         []v1.Taint        `json:"nodeTaints,omitempty"`
	DockerInfo         *DockerInfo       `json:"dockerInfo,omitempty"`
	NodePlan           *NodePlan         `json:"nodePlan,omitempty"`
	AppliedNodeVersion int               `json:"appliedNodeVersion,omitempty"`
}

func (*NodeStatus) DeepCopy 

func (in *NodeStatus) DeepCopy() *NodeStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeStatus.

func (*NodeStatus) DeepCopyInto 

func (in *NodeStatus) DeepCopyInto(out *NodeStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeTemplate 

type NodeTemplate struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec NodeTemplateSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status NodeTemplateStatus `json:"status"`
}

func NewNodeTemplate 

func NewNodeTemplate(namespace, name string, obj NodeTemplate) *NodeTemplate

func (*NodeTemplate) DeepCopy 

func (in *NodeTemplate) DeepCopy() *NodeTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeTemplate.

func (*NodeTemplate) DeepCopyInto 

func (in *NodeTemplate) DeepCopyInto(out *NodeTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodeTemplate) DeepCopyObject 

func (in *NodeTemplate) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type NodeTemplateChangeHandlerFunc 

type NodeTemplateChangeHandlerFunc func(obj *NodeTemplate) (runtime.Object, error)

type NodeTemplateCondition 

type NodeTemplateCondition struct {
	// Type of cluster condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
}

func (*NodeTemplateCondition) DeepCopy 

func (in *NodeTemplateCondition) DeepCopy() *NodeTemplateCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeTemplateCondition.

func (*NodeTemplateCondition) DeepCopyInto 

func (in *NodeTemplateCondition) DeepCopyInto(out *NodeTemplateCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeTemplateController 

type NodeTemplateController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() NodeTemplateLister
	AddHandler(ctx context.Context, name string, handler NodeTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodeTemplateHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler NodeTemplateHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type NodeTemplateHandlerFunc 

type NodeTemplateHandlerFunc func(key string, obj *NodeTemplate) (runtime.Object, error)

func NewNodeTemplateLifecycleAdapter 

func NewNodeTemplateLifecycleAdapter(name string, clusterScoped bool, client NodeTemplateInterface, l NodeTemplateLifecycle) NodeTemplateHandlerFunc

type NodeTemplateInterface 

type NodeTemplateInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*NodeTemplate) (*NodeTemplate, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*NodeTemplate, error)
	Get(name string, opts metav1.GetOptions) (*NodeTemplate, error)
	Update(*NodeTemplate) (*NodeTemplate, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*NodeTemplateList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*NodeTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() NodeTemplateController
	AddHandler(ctx context.Context, name string, sync NodeTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodeTemplateHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle NodeTemplateLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle NodeTemplateLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync NodeTemplateHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeTemplateLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle NodeTemplateLifecycle)
}

type NodeTemplateLifecycle 

type NodeTemplateLifecycle interface {
	Create(obj *NodeTemplate) (runtime.Object, error)
	Remove(obj *NodeTemplate) (runtime.Object, error)
	Updated(obj *NodeTemplate) (runtime.Object, error)
}

type NodeTemplateList 

type NodeTemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NodeTemplate `json:"items"`
}

func (*NodeTemplateList) DeepCopy 

func (in *NodeTemplateList) DeepCopy() *NodeTemplateList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeTemplateList.

func (*NodeTemplateList) DeepCopyInto 

func (in *NodeTemplateList) DeepCopyInto(out *NodeTemplateList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NodeTemplateList) DeepCopyObject 

func (in *NodeTemplateList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type NodeTemplateLister 

type NodeTemplateLister interface {
	List(namespace string, selector labels.Selector) (ret []*NodeTemplate, err error)
	Get(namespace, name string) (*NodeTemplate, error)
}

type NodeTemplateSpec 

type NodeTemplateSpec struct {
	DisplayName         string     `json:"displayName"`
	Description         string     `json:"description"`
	Driver              string     `json:"driver" norman:"nocreate,noupdate"`
	CloudCredentialName string     `json:"cloudCredentialName" norman:"type=reference[cloudCredential]"`
	NodeTaints          []v1.Taint `json:"nodeTaints,omitempty"`
	NodeCommonParams    `json:",inline"`
}

func (*NodeTemplateSpec) DeepCopy 

func (in *NodeTemplateSpec) DeepCopy() *NodeTemplateSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeTemplateSpec.

func (*NodeTemplateSpec) DeepCopyInto 

func (in *NodeTemplateSpec) DeepCopyInto(out *NodeTemplateSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeTemplateStatus 

type NodeTemplateStatus struct {
	Conditions []NodeTemplateCondition `json:"conditions"`
}

func (*NodeTemplateStatus) DeepCopy 

func (in *NodeTemplateStatus) DeepCopy() *NodeTemplateStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeTemplateStatus.

func (*NodeTemplateStatus) DeepCopyInto 

func (in *NodeTemplateStatus) DeepCopyInto(out *NodeTemplateStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodeTemplatesGetter 

type NodeTemplatesGetter interface {
	NodeTemplates(namespace string) NodeTemplateInterface
}

type NodeUpgradeStrategy 

type NodeUpgradeStrategy struct {
	// MaxUnavailableWorker input can be a number of nodes or a percentage of nodes (example, max_unavailable_worker: 2 OR max_unavailable_worker: 20%)
	MaxUnavailableWorker string `yaml:"max_unavailable_worker" json:"maxUnavailableWorker,omitempty" norman:"min=1,default=10%"`
	// MaxUnavailableControlplane input can be a number of nodes or a percentage of nodes
	MaxUnavailableControlplane string          `yaml:"max_unavailable_controlplane" json:"maxUnavailableControlplane,omitempty" norman:"min=1,default=1"`
	Drain                      bool            `yaml:"drain" json:"drain,omitempty"`
	DrainInput                 *NodeDrainInput `yaml:"node_drain_input" json:"nodeDrainInput,omitempty"`
}

func (*NodeUpgradeStrategy) DeepCopy 

func (in *NodeUpgradeStrategy) DeepCopy() *NodeUpgradeStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeUpgradeStrategy.

func (*NodeUpgradeStrategy) DeepCopyInto 

func (in *NodeUpgradeStrategy) DeepCopyInto(out *NodeUpgradeStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Nodelocal 

type Nodelocal struct {
	// link-local IP for nodelocal DNS
	IPAddress string `yaml:"ip_address" json:"ipAddress,omitempy"`
	// Nodelocal DNS daemonset upgrade strategy
	UpdateStrategy *DaemonSetUpdateStrategy `yaml:"update_strategy" json:"updateStrategy,omitempty"`
	// NodeSelector key pair
	NodeSelector map[string]string `yaml:"node_selector" json:"nodeSelector,omitempty"`
}

func (*Nodelocal) DeepCopy 

func (in *Nodelocal) DeepCopy() *Nodelocal

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Nodelocal.

func (*Nodelocal) DeepCopyInto 

func (in *Nodelocal) DeepCopyInto(out *Nodelocal)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NodesGetter 

type NodesGetter interface {
	Nodes(namespace string) NodeInterface
}

type Notification 

type Notification struct {
	Message         string           `json:"message,omitempty"`
	SMTPConfig      *SMTPConfig      `json:"smtpConfig,omitempty"`
	SlackConfig     *SlackConfig     `json:"slackConfig,omitempty"`
	PagerdutyConfig *PagerdutyConfig `json:"pagerdutyConfig,omitempty"`
	WebhookConfig   *WebhookConfig   `json:"webhookConfig,omitempty"`
	WechatConfig    *WechatConfig    `json:"wechatConfig,omitempty"`
	DingtalkConfig  *DingtalkConfig  `json:"dingtalkConfig,omitempty"`
	MSTeamsConfig   *MSTeamsConfig   `json:"msteamsConfig,omitempty"`
}

func (*Notification) DeepCopy 

func (in *Notification) DeepCopy() *Notification

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Notification.

func (*Notification) DeepCopyInto 

func (in *Notification) DeepCopyInto(out *Notification)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Notifier 

type Notifier struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec NotifierSpec `json:"spec"`
	// Most recent observed status of the notifier. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status NotifierStatus `json:"status"`
}

func NewNotifier 

func NewNotifier(namespace, name string, obj Notifier) *Notifier

func (*Notifier) DeepCopy 

func (in *Notifier) DeepCopy() *Notifier

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Notifier.

func (*Notifier) DeepCopyInto 

func (in *Notifier) DeepCopyInto(out *Notifier)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Notifier) DeepCopyObject 

func (in *Notifier) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*Notifier) ObjClusterName 

func (n *Notifier) ObjClusterName() string

type NotifierChangeHandlerFunc 

type NotifierChangeHandlerFunc func(obj *Notifier) (runtime.Object, error)

type NotifierController 

type NotifierController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() NotifierLister
	AddHandler(ctx context.Context, name string, handler NotifierHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NotifierHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NotifierHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler NotifierHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type NotifierHandlerFunc 

type NotifierHandlerFunc func(key string, obj *Notifier) (runtime.Object, error)

func NewNotifierLifecycleAdapter 

func NewNotifierLifecycleAdapter(name string, clusterScoped bool, client NotifierInterface, l NotifierLifecycle) NotifierHandlerFunc

type NotifierInterface 

type NotifierInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Notifier) (*Notifier, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Notifier, error)
	Get(name string, opts metav1.GetOptions) (*Notifier, error)
	Update(*Notifier) (*Notifier, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*NotifierList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*NotifierList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() NotifierController
	AddHandler(ctx context.Context, name string, sync NotifierHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NotifierHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle NotifierLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle NotifierLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NotifierHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync NotifierHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NotifierLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle NotifierLifecycle)
}

type NotifierLifecycle 

type NotifierLifecycle interface {
	Create(obj *Notifier) (runtime.Object, error)
	Remove(obj *Notifier) (runtime.Object, error)
	Updated(obj *Notifier) (runtime.Object, error)
}

type NotifierList 

type NotifierList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Notifier `json:"items"`
}

func (*NotifierList) DeepCopy 

func (in *NotifierList) DeepCopy() *NotifierList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NotifierList.

func (*NotifierList) DeepCopyInto 

func (in *NotifierList) DeepCopyInto(out *NotifierList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NotifierList) DeepCopyObject 

func (in *NotifierList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type NotifierLister 

type NotifierLister interface {
	List(namespace string, selector labels.Selector) (ret []*Notifier, err error)
	Get(namespace, name string) (*Notifier, error)
}

type NotifierSpec 

type NotifierSpec struct {
	ClusterName string `json:"clusterName" norman:"type=reference[cluster]"`

	DisplayName     string           `json:"displayName,omitempty" norman:"required"`
	Description     string           `json:"description,omitempty"`
	SendResolved    bool             `json:"sendResolved,omitempty"`
	SMTPConfig      *SMTPConfig      `json:"smtpConfig,omitempty"`
	SlackConfig     *SlackConfig     `json:"slackConfig,omitempty"`
	PagerdutyConfig *PagerdutyConfig `json:"pagerdutyConfig,omitempty"`
	WebhookConfig   *WebhookConfig   `json:"webhookConfig,omitempty"`
	WechatConfig    *WechatConfig    `json:"wechatConfig,omitempty"`
	DingtalkConfig  *DingtalkConfig  `json:"dingtalkConfig,omitempty"`
	MSTeamsConfig   *MSTeamsConfig   `json:"msteamsConfig,omitempty"`
}

func (*NotifierSpec) DeepCopy 

func (in *NotifierSpec) DeepCopy() *NotifierSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NotifierSpec.

func (*NotifierSpec) DeepCopyInto 

func (in *NotifierSpec) DeepCopyInto(out *NotifierSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*NotifierSpec) ObjClusterName 

func (n *NotifierSpec) ObjClusterName() string

type NotifierStatus 

type NotifierStatus struct {
	SMTPCredentialSecret     string `json:"smtpCredentialSecret,omitempty" norman:"nocreate,noupdate"`
	WechatCredentialSecret   string `json:"wechatCredentialSecret,omitempty" norman:"nocreate,noupdate"`
	DingtalkCredentialSecret string `json:"dingtalkCredentialSecret,omitempty" norman:"nocreate,noupdate"`
}

func (*NotifierStatus) DeepCopy 

func (in *NotifierStatus) DeepCopy() *NotifierStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NotifierStatus.

func (*NotifierStatus) DeepCopyInto 

func (in *NotifierStatus) DeepCopyInto(out *NotifierStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NotifiersGetter 

type NotifiersGetter interface {
	Notifiers(namespace string) NotifierInterface
}

type OKTAConfig 

type OKTAConfig struct {
	SamlConfig `json:",inline" mapstructure:",squash"`
}

func (*OKTAConfig) DeepCopy 

func (in *OKTAConfig) DeepCopy() *OKTAConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OKTAConfig.

func (*OKTAConfig) DeepCopyInto 

func (in *OKTAConfig) DeepCopyInto(out *OKTAConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*OKTAConfig) DeepCopyObject 

func (in *OKTAConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type OpenLdapConfig 

type OpenLdapConfig struct {
	LdapConfig `json:",inline" mapstructure:",squash"`
}

func (*OpenLdapConfig) DeepCopy 

func (in *OpenLdapConfig) DeepCopy() *OpenLdapConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenLdapConfig.

func (*OpenLdapConfig) DeepCopyInto 

func (in *OpenLdapConfig) DeepCopyInto(out *OpenLdapConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*OpenLdapConfig) DeepCopyObject 

func (in *OpenLdapConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type OpenLdapTestAndApplyInput 

type OpenLdapTestAndApplyInput struct {
	LdapTestAndApplyInput `json:",inline" mapstructure:",squash"`
}

func (*OpenLdapTestAndApplyInput) DeepCopy 

func (in *OpenLdapTestAndApplyInput) DeepCopy() *OpenLdapTestAndApplyInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenLdapTestAndApplyInput.

func (*OpenLdapTestAndApplyInput) DeepCopyInto 

func (in *OpenLdapTestAndApplyInput) DeepCopyInto(out *OpenLdapTestAndApplyInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*OpenLdapTestAndApplyInput) DeepCopyObject 

func (in *OpenLdapTestAndApplyInput) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type OpenstackCloudProvider 

type OpenstackCloudProvider struct {
	Global       GlobalOpenstackOpts       `json:"global" yaml:"global" ini:"Global,omitempty"`
	LoadBalancer LoadBalancerOpenstackOpts `json:"loadBalancer" yaml:"load_balancer" ini:"LoadBalancer,omitempty"`
	BlockStorage BlockStorageOpenstackOpts `json:"blockStorage" yaml:"block_storage" ini:"BlockStorage,omitempty"`
	Route        RouteOpenstackOpts        `json:"route" yaml:"route" ini:"Route,omitempty"`
	Metadata     MetadataOpenstackOpts     `json:"metadata" yaml:"metadata" ini:"Metadata,omitempty"`
}

OpenstackCloudProvider options

func (*OpenstackCloudProvider) DeepCopy 

func (in *OpenstackCloudProvider) DeepCopy() *OpenstackCloudProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenstackCloudProvider.

func (*OpenstackCloudProvider) DeepCopyInto 

func (in *OpenstackCloudProvider) DeepCopyInto(out *OpenstackCloudProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PagerdutyConfig 

type PagerdutyConfig struct {
	ServiceKey string `json:"serviceKey,omitempty" norman:"required"`
	*HTTPClientConfig
}

func (*PagerdutyConfig) DeepCopy 

func (in *PagerdutyConfig) DeepCopy() *PagerdutyConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PagerdutyConfig.

func (*PagerdutyConfig) DeepCopyInto 

func (in *PagerdutyConfig) DeepCopyInto(out *PagerdutyConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PingConfig 

type PingConfig struct {
	SamlConfig `json:",inline" mapstructure:",squash"`
}

func (*PingConfig) DeepCopy 

func (in *PingConfig) DeepCopy() *PingConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PingConfig.

func (*PingConfig) DeepCopyInto 

func (in *PingConfig) DeepCopyInto(out *PingConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PingConfig) DeepCopyObject 

func (in *PingConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PodRule 

type PodRule struct {
	PodName                string `json:"podName,omitempty" norman:"required,type=reference[/v3/projects/schemas/pod]"`
	Condition              string `json:"condition,omitempty" norman:"required,options=notrunning|notscheduled|restarts,default=notrunning"`
	RestartTimes           int    `json:"restartTimes,omitempty" norman:"min=1,default=3"`
	RestartIntervalSeconds int    `json:"restartIntervalSeconds,omitempty"  norman:"min=1,default=300"`
}

func (*PodRule) DeepCopy 

func (in *PodRule) DeepCopy() *PodRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodRule.

func (*PodRule) DeepCopyInto 

func (in *PodRule) DeepCopyInto(out *PodRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PodSecurityPolicyTemplate 

type PodSecurityPolicyTemplate struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Description string                         `json:"description"`
	Spec        policyv1.PodSecurityPolicySpec `json:"spec,omitempty"`
}

func NewPodSecurityPolicyTemplate 

func NewPodSecurityPolicyTemplate(namespace, name string, obj PodSecurityPolicyTemplate) *PodSecurityPolicyTemplate

func (*PodSecurityPolicyTemplate) DeepCopy 

func (in *PodSecurityPolicyTemplate) DeepCopy() *PodSecurityPolicyTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSecurityPolicyTemplate.

func (*PodSecurityPolicyTemplate) DeepCopyInto 

func (in *PodSecurityPolicyTemplate) DeepCopyInto(out *PodSecurityPolicyTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PodSecurityPolicyTemplate) DeepCopyObject 

func (in *PodSecurityPolicyTemplate) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PodSecurityPolicyTemplateChangeHandlerFunc 

type PodSecurityPolicyTemplateChangeHandlerFunc func(obj *PodSecurityPolicyTemplate) (runtime.Object, error)

type PodSecurityPolicyTemplateController 

type PodSecurityPolicyTemplateController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() PodSecurityPolicyTemplateLister
	AddHandler(ctx context.Context, name string, handler PodSecurityPolicyTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PodSecurityPolicyTemplateHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PodSecurityPolicyTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler PodSecurityPolicyTemplateHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type PodSecurityPolicyTemplateHandlerFunc 

type PodSecurityPolicyTemplateHandlerFunc func(key string, obj *PodSecurityPolicyTemplate) (runtime.Object, error)

func NewPodSecurityPolicyTemplateLifecycleAdapter 

func NewPodSecurityPolicyTemplateLifecycleAdapter(name string, clusterScoped bool, client PodSecurityPolicyTemplateInterface, l PodSecurityPolicyTemplateLifecycle) PodSecurityPolicyTemplateHandlerFunc

type PodSecurityPolicyTemplateInterface 

type PodSecurityPolicyTemplateInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplate, error)
	Get(name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplate, error)
	Update(*PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*PodSecurityPolicyTemplateList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() PodSecurityPolicyTemplateController
	AddHandler(ctx context.Context, name string, sync PodSecurityPolicyTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PodSecurityPolicyTemplateHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyTemplateLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle PodSecurityPolicyTemplateLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync PodSecurityPolicyTemplateHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyTemplateLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle PodSecurityPolicyTemplateLifecycle)
}

type PodSecurityPolicyTemplateLifecycle 

type PodSecurityPolicyTemplateLifecycle interface {
	Create(obj *PodSecurityPolicyTemplate) (runtime.Object, error)
	Remove(obj *PodSecurityPolicyTemplate) (runtime.Object, error)
	Updated(obj *PodSecurityPolicyTemplate) (runtime.Object, error)
}

type PodSecurityPolicyTemplateList 

type PodSecurityPolicyTemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []PodSecurityPolicyTemplate `json:"items"`
}

func (*PodSecurityPolicyTemplateList) DeepCopy 

func (in *PodSecurityPolicyTemplateList) DeepCopy() *PodSecurityPolicyTemplateList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSecurityPolicyTemplateList.

func (*PodSecurityPolicyTemplateList) DeepCopyInto 

func (in *PodSecurityPolicyTemplateList) DeepCopyInto(out *PodSecurityPolicyTemplateList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PodSecurityPolicyTemplateList) DeepCopyObject 

func (in *PodSecurityPolicyTemplateList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PodSecurityPolicyTemplateLister 

type PodSecurityPolicyTemplateLister interface {
	List(namespace string, selector labels.Selector) (ret []*PodSecurityPolicyTemplate, err error)
	Get(namespace, name string) (*PodSecurityPolicyTemplate, error)
}

type PodSecurityPolicyTemplateProjectBinding 

type PodSecurityPolicyTemplateProjectBinding struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	PodSecurityPolicyTemplateName string `json:"podSecurityPolicyTemplateId" norman:"required,type=reference[podSecurityPolicyTemplate]"`
	TargetProjectName             string `json:"targetProjectId" norman:"required,type=reference[project]"`
}

func NewPodSecurityPolicyTemplateProjectBinding 

func NewPodSecurityPolicyTemplateProjectBinding(namespace, name string, obj PodSecurityPolicyTemplateProjectBinding) *PodSecurityPolicyTemplateProjectBinding

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopy 

func (in *PodSecurityPolicyTemplateProjectBinding) DeepCopy() *PodSecurityPolicyTemplateProjectBinding

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSecurityPolicyTemplateProjectBinding.

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopyInto 

func (in *PodSecurityPolicyTemplateProjectBinding) DeepCopyInto(out *PodSecurityPolicyTemplateProjectBinding)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopyObject 

func (in *PodSecurityPolicyTemplateProjectBinding) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc 

type PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc func(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error)

type PodSecurityPolicyTemplateProjectBindingController 

type PodSecurityPolicyTemplateProjectBindingController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() PodSecurityPolicyTemplateProjectBindingLister
	AddHandler(ctx context.Context, name string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type PodSecurityPolicyTemplateProjectBindingHandlerFunc 

type PodSecurityPolicyTemplateProjectBindingHandlerFunc func(key string, obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error)

func NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter 

func NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter(name string, clusterScoped bool, client PodSecurityPolicyTemplateProjectBindingInterface, l PodSecurityPolicyTemplateProjectBindingLifecycle) PodSecurityPolicyTemplateProjectBindingHandlerFunc

type PodSecurityPolicyTemplateProjectBindingInterface 

type PodSecurityPolicyTemplateProjectBindingInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplateProjectBinding, error)
	Get(name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplateProjectBinding, error)
	Update(*PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*PodSecurityPolicyTemplateProjectBindingList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyTemplateProjectBindingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() PodSecurityPolicyTemplateProjectBindingController
	AddHandler(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle)
}

type PodSecurityPolicyTemplateProjectBindingLifecycle 

type PodSecurityPolicyTemplateProjectBindingLifecycle interface {
	Create(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error)
	Remove(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error)
	Updated(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error)
}

type PodSecurityPolicyTemplateProjectBindingList 

type PodSecurityPolicyTemplateProjectBindingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []PodSecurityPolicyTemplateProjectBinding `json:"items"`
}

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopy 

func (in *PodSecurityPolicyTemplateProjectBindingList) DeepCopy() *PodSecurityPolicyTemplateProjectBindingList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSecurityPolicyTemplateProjectBindingList.

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopyInto 

func (in *PodSecurityPolicyTemplateProjectBindingList) DeepCopyInto(out *PodSecurityPolicyTemplateProjectBindingList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopyObject 

func (in *PodSecurityPolicyTemplateProjectBindingList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PodSecurityPolicyTemplateProjectBindingLister 

type PodSecurityPolicyTemplateProjectBindingLister interface {
	List(namespace string, selector labels.Selector) (ret []*PodSecurityPolicyTemplateProjectBinding, err error)
	Get(namespace, name string) (*PodSecurityPolicyTemplateProjectBinding, error)
}

type PodSecurityPolicyTemplateProjectBindingsGetter 

type PodSecurityPolicyTemplateProjectBindingsGetter interface {
	PodSecurityPolicyTemplateProjectBindings(namespace string) PodSecurityPolicyTemplateProjectBindingInterface
}

type PodSecurityPolicyTemplatesGetter 

type PodSecurityPolicyTemplatesGetter interface {
	PodSecurityPolicyTemplates(namespace string) PodSecurityPolicyTemplateInterface
}

type PortCheck 

type PortCheck struct {
	// Portcheck address to check.
	Address string `json:"address,omitempty"`
	// Port number
	Port int `json:"port,omitempty"`
	// Port Protocol
	Protocol string `json:"protocol,omitempty"`
}

func (*PortCheck) DeepCopy 

func (in *PortCheck) DeepCopy() *PortCheck

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PortCheck.

func (*PortCheck) DeepCopyInto 

func (in *PortCheck) DeepCopyInto(out *PortCheck)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Preference 

type Preference struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Value string `json:"value" norman:"required"`
}

func NewPreference 

func NewPreference(namespace, name string, obj Preference) *Preference

func (*Preference) DeepCopy 

func (in *Preference) DeepCopy() *Preference

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Preference.

func (*Preference) DeepCopyInto 

func (in *Preference) DeepCopyInto(out *Preference)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Preference) DeepCopyObject 

func (in *Preference) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PreferenceChangeHandlerFunc 

type PreferenceChangeHandlerFunc func(obj *Preference) (runtime.Object, error)

type PreferenceController 

type PreferenceController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() PreferenceLister
	AddHandler(ctx context.Context, name string, handler PreferenceHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PreferenceHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PreferenceHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler PreferenceHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type PreferenceHandlerFunc 

type PreferenceHandlerFunc func(key string, obj *Preference) (runtime.Object, error)

func NewPreferenceLifecycleAdapter 

func NewPreferenceLifecycleAdapter(name string, clusterScoped bool, client PreferenceInterface, l PreferenceLifecycle) PreferenceHandlerFunc

type PreferenceInterface 

type PreferenceInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Preference) (*Preference, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Preference, error)
	Get(name string, opts metav1.GetOptions) (*Preference, error)
	Update(*Preference) (*Preference, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*PreferenceList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*PreferenceList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() PreferenceController
	AddHandler(ctx context.Context, name string, sync PreferenceHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PreferenceHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle PreferenceLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle PreferenceLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PreferenceHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync PreferenceHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PreferenceLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle PreferenceLifecycle)
}

type PreferenceLifecycle 

type PreferenceLifecycle interface {
	Create(obj *Preference) (runtime.Object, error)
	Remove(obj *Preference) (runtime.Object, error)
	Updated(obj *Preference) (runtime.Object, error)
}

type PreferenceList 

type PreferenceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Preference `json:"items"`
}

func (*PreferenceList) DeepCopy 

func (in *PreferenceList) DeepCopy() *PreferenceList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PreferenceList.

func (*PreferenceList) DeepCopyInto 

func (in *PreferenceList) DeepCopyInto(out *PreferenceList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PreferenceList) DeepCopyObject 

func (in *PreferenceList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PreferenceLister 

type PreferenceLister interface {
	List(namespace string, selector labels.Selector) (ret []*Preference, err error)
	Get(namespace, name string) (*Preference, error)
}

type PreferencesGetter 

type PreferencesGetter interface {
	Preferences(namespace string) PreferenceInterface
}

type Principal 

type Principal struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	DisplayName    string            `json:"displayName,omitempty"`
	LoginName      string            `json:"loginName,omitempty"`
	ProfilePicture string            `json:"profilePicture,omitempty"`
	ProfileURL     string            `json:"profileURL,omitempty"`
	PrincipalType  string            `json:"principalType,omitempty"`
	Me             bool              `json:"me,omitempty"`
	MemberOf       bool              `json:"memberOf,omitempty"`
	Provider       string            `json:"provider,omitempty"`
	ExtraInfo      map[string]string `json:"extraInfo,omitempty"`
}

func NewPrincipal 

func NewPrincipal(namespace, name string, obj Principal) *Principal

func (*Principal) DeepCopy 

func (in *Principal) DeepCopy() *Principal

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Principal.

func (*Principal) DeepCopyInto 

func (in *Principal) DeepCopyInto(out *Principal)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Principal) DeepCopyObject 

func (in *Principal) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PrincipalChangeHandlerFunc 

type PrincipalChangeHandlerFunc func(obj *Principal) (runtime.Object, error)

type PrincipalController 

type PrincipalController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() PrincipalLister
	AddHandler(ctx context.Context, name string, handler PrincipalHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PrincipalHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PrincipalHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler PrincipalHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type PrincipalHandlerFunc 

type PrincipalHandlerFunc func(key string, obj *Principal) (runtime.Object, error)

func NewPrincipalLifecycleAdapter 

func NewPrincipalLifecycleAdapter(name string, clusterScoped bool, client PrincipalInterface, l PrincipalLifecycle) PrincipalHandlerFunc

type PrincipalInterface 

type PrincipalInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Principal) (*Principal, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Principal, error)
	Get(name string, opts metav1.GetOptions) (*Principal, error)
	Update(*Principal) (*Principal, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*PrincipalList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*PrincipalList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() PrincipalController
	AddHandler(ctx context.Context, name string, sync PrincipalHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync PrincipalHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle PrincipalLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle PrincipalLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PrincipalHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync PrincipalHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PrincipalLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle PrincipalLifecycle)
}

type PrincipalLifecycle 

type PrincipalLifecycle interface {
	Create(obj *Principal) (runtime.Object, error)
	Remove(obj *Principal) (runtime.Object, error)
	Updated(obj *Principal) (runtime.Object, error)
}

type PrincipalList 

type PrincipalList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Principal `json:"items"`
}

func (*PrincipalList) DeepCopy 

func (in *PrincipalList) DeepCopy() *PrincipalList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrincipalList.

func (*PrincipalList) DeepCopyInto 

func (in *PrincipalList) DeepCopyInto(out *PrincipalList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PrincipalList) DeepCopyObject 

func (in *PrincipalList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PrincipalLister 

type PrincipalLister interface {
	List(namespace string, selector labels.Selector) (ret []*Principal, err error)
	Get(namespace, name string) (*Principal, error)
}

type Principals 

type Principals struct {
	Items []Principal
}

func (*Principals) DeepCopy 

func (in *Principals) DeepCopy() *Principals

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Principals.

func (*Principals) DeepCopyInto 

func (in *Principals) DeepCopyInto(out *Principals)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PrincipalsGetter 

type PrincipalsGetter interface {
	Principals(namespace string) PrincipalInterface
}

type PrivateRegistry 

type PrivateRegistry struct {
	// URL for the registry
	URL string `yaml:"url" json:"url,omitempty"`
	// User name for registry acces
	User string `yaml:"user" json:"user,omitempty"`
	// Password for registry access
	Password string `yaml:"password" json:"password,omitempty" norman:"type=password"`
	// Default registry
	IsDefault bool `yaml:"is_default" json:"isDefault,omitempty"`
}

func (*PrivateRegistry) DeepCopy 

func (in *PrivateRegistry) DeepCopy() *PrivateRegistry

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrivateRegistry.

func (*PrivateRegistry) DeepCopyInto 

func (in *PrivateRegistry) DeepCopyInto(out *PrivateRegistry)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Process 

type Process struct {
	// Process name, this should be the container name
	Name string `json:"name,omitempty"`
	// Process Entrypoint command
	Command []string `json:"command,omitempty"`
	// Process args
	Args []string `json:"args,omitempty"`
	// Environment variables list
	Env []string `json:"env,omitempty"`
	// Process docker image
	Image string `json:"image,omitempty"`
	//AuthConfig for image private registry
	ImageRegistryAuthConfig string `json:"imageRegistryAuthConfig,omitempty"`
	// Process docker image VolumesFrom
	VolumesFrom []string `json:"volumesFrom,omitempty"`
	// Process docker container bind mounts
	Binds []string `json:"binds,omitempty"`
	// Process docker container netwotk mode
	NetworkMode string `json:"networkMode,omitempty"`
	// Process container restart policy
	RestartPolicy string `json:"restartPolicy,omitempty"`
	// Process container pid mode
	PidMode string `json:"pidMode,omitempty"`
	// Run process in privileged container
	Privileged bool `json:"privileged,omitempty"`
	// Process healthcheck
	HealthCheck HealthCheck `json:"healthCheck,omitempty"`
	// Process docker container Labels
	Labels map[string]string `json:"labels,omitempty"`
	// Process docker publish container's port to host
	Publish []string `json:"publish,omitempty"`
	// docker will run the container with this user
	User string `json:"user,omitempty"`
}

func (*Process) DeepCopy 

func (in *Process) DeepCopy() *Process

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Process.

func (*Process) DeepCopyInto 

func (in *Process) DeepCopyInto(out *Process)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Project 

type Project struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ProjectSpec   `json:"spec,omitempty"`
	Status ProjectStatus `json:"status"`
}

func NewProject 

func NewProject(namespace, name string, obj Project) *Project

func (*Project) DeepCopy 

func (in *Project) DeepCopy() *Project

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Project.

func (*Project) DeepCopyInto 

func (in *Project) DeepCopyInto(out *Project)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Project) DeepCopyObject 

func (in *Project) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*Project) ObjClusterName 

func (p *Project) ObjClusterName() string

type ProjectAlert 

type ProjectAlert struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ProjectAlertSpec `json:"spec"`
	// Most recent observed status of the alert. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status AlertStatus `json:"status"`
}

func NewProjectAlert 

func NewProjectAlert(namespace, name string, obj ProjectAlert) *ProjectAlert

func (*ProjectAlert) DeepCopy 

func (in *ProjectAlert) DeepCopy() *ProjectAlert

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlert.

func (*ProjectAlert) DeepCopyInto 

func (in *ProjectAlert) DeepCopyInto(out *ProjectAlert)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlert) DeepCopyObject 

func (in *ProjectAlert) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ProjectAlert) ObjClusterName 

func (p *ProjectAlert) ObjClusterName() string

type ProjectAlertChangeHandlerFunc 

type ProjectAlertChangeHandlerFunc func(obj *ProjectAlert) (runtime.Object, error)

type ProjectAlertController 

type ProjectAlertController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectAlertLister
	AddHandler(ctx context.Context, name string, handler ProjectAlertHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectAlertHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectAlertHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectAlertHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectAlertGroup 

type ProjectAlertGroup struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ProjectGroupSpec `json:"spec"`
	// Most recent observed status of the alert. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status AlertStatus `json:"status"`
}

func NewProjectAlertGroup 

func NewProjectAlertGroup(namespace, name string, obj ProjectAlertGroup) *ProjectAlertGroup

func (*ProjectAlertGroup) DeepCopy 

func (in *ProjectAlertGroup) DeepCopy() *ProjectAlertGroup

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlertGroup.

func (*ProjectAlertGroup) DeepCopyInto 

func (in *ProjectAlertGroup) DeepCopyInto(out *ProjectAlertGroup)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlertGroup) DeepCopyObject 

func (in *ProjectAlertGroup) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ProjectAlertGroup) ObjClusterName 

func (p *ProjectAlertGroup) ObjClusterName() string

type ProjectAlertGroupChangeHandlerFunc 

type ProjectAlertGroupChangeHandlerFunc func(obj *ProjectAlertGroup) (runtime.Object, error)

type ProjectAlertGroupController 

type ProjectAlertGroupController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectAlertGroupLister
	AddHandler(ctx context.Context, name string, handler ProjectAlertGroupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectAlertGroupHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectAlertGroupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectAlertGroupHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectAlertGroupHandlerFunc 

type ProjectAlertGroupHandlerFunc func(key string, obj *ProjectAlertGroup) (runtime.Object, error)

func NewProjectAlertGroupLifecycleAdapter 

func NewProjectAlertGroupLifecycleAdapter(name string, clusterScoped bool, client ProjectAlertGroupInterface, l ProjectAlertGroupLifecycle) ProjectAlertGroupHandlerFunc

type ProjectAlertGroupInterface 

type ProjectAlertGroupInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectAlertGroup) (*ProjectAlertGroup, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectAlertGroup, error)
	Get(name string, opts metav1.GetOptions) (*ProjectAlertGroup, error)
	Update(*ProjectAlertGroup) (*ProjectAlertGroup, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectAlertGroupList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectAlertGroupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectAlertGroupController
	AddHandler(ctx context.Context, name string, sync ProjectAlertGroupHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectAlertGroupHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectAlertGroupLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectAlertGroupLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectAlertGroupHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectAlertGroupHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectAlertGroupLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectAlertGroupLifecycle)
}

type ProjectAlertGroupLifecycle 

type ProjectAlertGroupLifecycle interface {
	Create(obj *ProjectAlertGroup) (runtime.Object, error)
	Remove(obj *ProjectAlertGroup) (runtime.Object, error)
	Updated(obj *ProjectAlertGroup) (runtime.Object, error)
}

type ProjectAlertGroupList 

type ProjectAlertGroupList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectAlertGroup `json:"items"`
}

func (*ProjectAlertGroupList) DeepCopy 

func (in *ProjectAlertGroupList) DeepCopy() *ProjectAlertGroupList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlertGroupList.

func (*ProjectAlertGroupList) DeepCopyInto 

func (in *ProjectAlertGroupList) DeepCopyInto(out *ProjectAlertGroupList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlertGroupList) DeepCopyObject 

func (in *ProjectAlertGroupList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectAlertGroupLister 

type ProjectAlertGroupLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectAlertGroup, err error)
	Get(namespace, name string) (*ProjectAlertGroup, error)
}

type ProjectAlertGroupsGetter 

type ProjectAlertGroupsGetter interface {
	ProjectAlertGroups(namespace string) ProjectAlertGroupInterface
}

type ProjectAlertHandlerFunc 

type ProjectAlertHandlerFunc func(key string, obj *ProjectAlert) (runtime.Object, error)

func NewProjectAlertLifecycleAdapter 

func NewProjectAlertLifecycleAdapter(name string, clusterScoped bool, client ProjectAlertInterface, l ProjectAlertLifecycle) ProjectAlertHandlerFunc

type ProjectAlertInterface 

type ProjectAlertInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectAlert) (*ProjectAlert, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectAlert, error)
	Get(name string, opts metav1.GetOptions) (*ProjectAlert, error)
	Update(*ProjectAlert) (*ProjectAlert, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectAlertList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectAlertList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectAlertController
	AddHandler(ctx context.Context, name string, sync ProjectAlertHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectAlertHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectAlertLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectAlertLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectAlertHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectAlertHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectAlertLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectAlertLifecycle)
}

type ProjectAlertLifecycle 

type ProjectAlertLifecycle interface {
	Create(obj *ProjectAlert) (runtime.Object, error)
	Remove(obj *ProjectAlert) (runtime.Object, error)
	Updated(obj *ProjectAlert) (runtime.Object, error)
}

type ProjectAlertList 

type ProjectAlertList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectAlert `json:"items"`
}

func (*ProjectAlertList) DeepCopy 

func (in *ProjectAlertList) DeepCopy() *ProjectAlertList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlertList.

func (*ProjectAlertList) DeepCopyInto 

func (in *ProjectAlertList) DeepCopyInto(out *ProjectAlertList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlertList) DeepCopyObject 

func (in *ProjectAlertList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectAlertLister 

type ProjectAlertLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectAlert, err error)
	Get(namespace, name string) (*ProjectAlert, error)
}

type ProjectAlertRule 

type ProjectAlertRule struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ProjectAlertRuleSpec `json:"spec"`
	// Most recent observed status of the alert. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status AlertStatus `json:"status"`
}

func NewProjectAlertRule 

func NewProjectAlertRule(namespace, name string, obj ProjectAlertRule) *ProjectAlertRule

func (*ProjectAlertRule) DeepCopy 

func (in *ProjectAlertRule) DeepCopy() *ProjectAlertRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlertRule.

func (*ProjectAlertRule) DeepCopyInto 

func (in *ProjectAlertRule) DeepCopyInto(out *ProjectAlertRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlertRule) DeepCopyObject 

func (in *ProjectAlertRule) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ProjectAlertRule) ObjClusterName 

func (p *ProjectAlertRule) ObjClusterName() string

type ProjectAlertRuleChangeHandlerFunc 

type ProjectAlertRuleChangeHandlerFunc func(obj *ProjectAlertRule) (runtime.Object, error)

type ProjectAlertRuleController 

type ProjectAlertRuleController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectAlertRuleLister
	AddHandler(ctx context.Context, name string, handler ProjectAlertRuleHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectAlertRuleHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectAlertRuleHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectAlertRuleHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectAlertRuleHandlerFunc 

type ProjectAlertRuleHandlerFunc func(key string, obj *ProjectAlertRule) (runtime.Object, error)

func NewProjectAlertRuleLifecycleAdapter 

func NewProjectAlertRuleLifecycleAdapter(name string, clusterScoped bool, client ProjectAlertRuleInterface, l ProjectAlertRuleLifecycle) ProjectAlertRuleHandlerFunc

type ProjectAlertRuleInterface 

type ProjectAlertRuleInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectAlertRule) (*ProjectAlertRule, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectAlertRule, error)
	Get(name string, opts metav1.GetOptions) (*ProjectAlertRule, error)
	Update(*ProjectAlertRule) (*ProjectAlertRule, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectAlertRuleList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectAlertRuleList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectAlertRuleController
	AddHandler(ctx context.Context, name string, sync ProjectAlertRuleHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectAlertRuleHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectAlertRuleLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectAlertRuleLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectAlertRuleHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectAlertRuleHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectAlertRuleLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectAlertRuleLifecycle)
}

type ProjectAlertRuleLifecycle 

type ProjectAlertRuleLifecycle interface {
	Create(obj *ProjectAlertRule) (runtime.Object, error)
	Remove(obj *ProjectAlertRule) (runtime.Object, error)
	Updated(obj *ProjectAlertRule) (runtime.Object, error)
}

type ProjectAlertRuleList 

type ProjectAlertRuleList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectAlertRule `json:"items"`
}

func (*ProjectAlertRuleList) DeepCopy 

func (in *ProjectAlertRuleList) DeepCopy() *ProjectAlertRuleList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlertRuleList.

func (*ProjectAlertRuleList) DeepCopyInto 

func (in *ProjectAlertRuleList) DeepCopyInto(out *ProjectAlertRuleList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlertRuleList) DeepCopyObject 

func (in *ProjectAlertRuleList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectAlertRuleLister 

type ProjectAlertRuleLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectAlertRule, err error)
	Get(namespace, name string) (*ProjectAlertRule, error)
}

type ProjectAlertRuleSpec 

type ProjectAlertRuleSpec struct {
	CommonRuleField
	ProjectName  string        `json:"projectName" norman:"type=reference[project]"`
	GroupName    string        `json:"groupName" norman:"type=reference[projectAlertGroup]"`
	PodRule      *PodRule      `json:"podRule,omitempty"`
	WorkloadRule *WorkloadRule `json:"workloadRule,omitempty"`
	MetricRule   *MetricRule   `json:"metricRule,omitempty"`
}

func (*ProjectAlertRuleSpec) DeepCopy 

func (in *ProjectAlertRuleSpec) DeepCopy() *ProjectAlertRuleSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlertRuleSpec.

func (*ProjectAlertRuleSpec) DeepCopyInto 

func (in *ProjectAlertRuleSpec) DeepCopyInto(out *ProjectAlertRuleSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlertRuleSpec) ObjClusterName 

func (p *ProjectAlertRuleSpec) ObjClusterName() string

type ProjectAlertRulesGetter 

type ProjectAlertRulesGetter interface {
	ProjectAlertRules(namespace string) ProjectAlertRuleInterface
}

type ProjectAlertSpec 

type ProjectAlertSpec struct {
	AlertCommonSpec

	ProjectName    string          `json:"projectName" norman:"type=reference[project]"`
	TargetWorkload *TargetWorkload `json:"targetWorkload,omitempty"`
	TargetPod      *TargetPod      `json:"targetPod,omitempty"`
}

func (*ProjectAlertSpec) DeepCopy 

func (in *ProjectAlertSpec) DeepCopy() *ProjectAlertSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectAlertSpec.

func (*ProjectAlertSpec) DeepCopyInto 

func (in *ProjectAlertSpec) DeepCopyInto(out *ProjectAlertSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectAlertSpec) ObjClusterName 

func (p *ProjectAlertSpec) ObjClusterName() string

type ProjectAlertsGetter 

type ProjectAlertsGetter interface {
	ProjectAlerts(namespace string) ProjectAlertInterface
}

type ProjectCatalog 

type ProjectCatalog struct {
	types.Namespaced

	Catalog     `json:",inline" mapstructure:",squash"`
	ProjectName string `json:"projectName,omitempty" norman:"type=reference[project]"`
}

func NewProjectCatalog 

func NewProjectCatalog(namespace, name string, obj ProjectCatalog) *ProjectCatalog

func (*ProjectCatalog) DeepCopy 

func (in *ProjectCatalog) DeepCopy() *ProjectCatalog

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectCatalog.

func (*ProjectCatalog) DeepCopyInto 

func (in *ProjectCatalog) DeepCopyInto(out *ProjectCatalog)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectCatalog) DeepCopyObject 

func (in *ProjectCatalog) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ProjectCatalog) ObjClusterName 

func (p *ProjectCatalog) ObjClusterName() string

type ProjectCatalogChangeHandlerFunc 

type ProjectCatalogChangeHandlerFunc func(obj *ProjectCatalog) (runtime.Object, error)

type ProjectCatalogController 

type ProjectCatalogController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectCatalogLister
	AddHandler(ctx context.Context, name string, handler ProjectCatalogHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectCatalogHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectCatalogHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectCatalogHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectCatalogHandlerFunc 

type ProjectCatalogHandlerFunc func(key string, obj *ProjectCatalog) (runtime.Object, error)

func NewProjectCatalogLifecycleAdapter 

func NewProjectCatalogLifecycleAdapter(name string, clusterScoped bool, client ProjectCatalogInterface, l ProjectCatalogLifecycle) ProjectCatalogHandlerFunc

type ProjectCatalogInterface 

type ProjectCatalogInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectCatalog) (*ProjectCatalog, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectCatalog, error)
	Get(name string, opts metav1.GetOptions) (*ProjectCatalog, error)
	Update(*ProjectCatalog) (*ProjectCatalog, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectCatalogList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectCatalogList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectCatalogController
	AddHandler(ctx context.Context, name string, sync ProjectCatalogHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectCatalogHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectCatalogLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectCatalogLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectCatalogHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectCatalogHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectCatalogLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectCatalogLifecycle)
}

type ProjectCatalogLifecycle 

type ProjectCatalogLifecycle interface {
	Create(obj *ProjectCatalog) (runtime.Object, error)
	Remove(obj *ProjectCatalog) (runtime.Object, error)
	Updated(obj *ProjectCatalog) (runtime.Object, error)
}

type ProjectCatalogList 

type ProjectCatalogList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectCatalog `json:"items"`
}

func (*ProjectCatalogList) DeepCopy 

func (in *ProjectCatalogList) DeepCopy() *ProjectCatalogList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectCatalogList.

func (*ProjectCatalogList) DeepCopyInto 

func (in *ProjectCatalogList) DeepCopyInto(out *ProjectCatalogList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectCatalogList) DeepCopyObject 

func (in *ProjectCatalogList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectCatalogLister 

type ProjectCatalogLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectCatalog, err error)
	Get(namespace, name string) (*ProjectCatalog, error)
}

type ProjectCatalogsGetter 

type ProjectCatalogsGetter interface {
	ProjectCatalogs(namespace string) ProjectCatalogInterface
}

type ProjectChangeHandlerFunc 

type ProjectChangeHandlerFunc func(obj *Project) (runtime.Object, error)

type ProjectCondition 

type ProjectCondition struct {
	// Type of project condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*ProjectCondition) DeepCopy 

func (in *ProjectCondition) DeepCopy() *ProjectCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectCondition.

func (*ProjectCondition) DeepCopyInto 

func (in *ProjectCondition) DeepCopyInto(out *ProjectCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ProjectController 

type ProjectController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectLister
	AddHandler(ctx context.Context, name string, handler ProjectHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectGroupSpec 

type ProjectGroupSpec struct {
	ProjectName string      `json:"projectName" norman:"type=reference[project]"`
	Recipients  []Recipient `json:"recipients,omitempty"`
	CommonGroupField
}

func (*ProjectGroupSpec) DeepCopy 

func (in *ProjectGroupSpec) DeepCopy() *ProjectGroupSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectGroupSpec.

func (*ProjectGroupSpec) DeepCopyInto 

func (in *ProjectGroupSpec) DeepCopyInto(out *ProjectGroupSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectGroupSpec) ObjClusterName 

func (p *ProjectGroupSpec) ObjClusterName() string

type ProjectHandlerFunc 

type ProjectHandlerFunc func(key string, obj *Project) (runtime.Object, error)

func NewProjectLifecycleAdapter 

func NewProjectLifecycleAdapter(name string, clusterScoped bool, client ProjectInterface, l ProjectLifecycle) ProjectHandlerFunc

type ProjectInterface 

type ProjectInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Project) (*Project, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Project, error)
	Get(name string, opts metav1.GetOptions) (*Project, error)
	Update(*Project) (*Project, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectController
	AddHandler(ctx context.Context, name string, sync ProjectHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectLifecycle)
}

type ProjectLifecycle 

type ProjectLifecycle interface {
	Create(obj *Project) (runtime.Object, error)
	Remove(obj *Project) (runtime.Object, error)
	Updated(obj *Project) (runtime.Object, error)
}

type ProjectList 

type ProjectList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Project `json:"items"`
}

func (*ProjectList) DeepCopy 

func (in *ProjectList) DeepCopy() *ProjectList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectList.

func (*ProjectList) DeepCopyInto 

func (in *ProjectList) DeepCopyInto(out *ProjectList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectList) DeepCopyObject 

func (in *ProjectList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectLister 

type ProjectLister interface {
	List(namespace string, selector labels.Selector) (ret []*Project, err error)
	Get(namespace, name string) (*Project, error)
}

type ProjectLogging 

type ProjectLogging struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec ProjectLoggingSpec `json:"spec"`
	// Most recent observed status of the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Status ProjectLoggingStatus `json:"status"`
}

func NewProjectLogging 

func NewProjectLogging(namespace, name string, obj ProjectLogging) *ProjectLogging

func (*ProjectLogging) DeepCopy 

func (in *ProjectLogging) DeepCopy() *ProjectLogging

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectLogging.

func (*ProjectLogging) DeepCopyInto 

func (in *ProjectLogging) DeepCopyInto(out *ProjectLogging)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectLogging) DeepCopyObject 

func (in *ProjectLogging) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ProjectLogging) ObjClusterName 

func (p *ProjectLogging) ObjClusterName() string

type ProjectLoggingChangeHandlerFunc 

type ProjectLoggingChangeHandlerFunc func(obj *ProjectLogging) (runtime.Object, error)

type ProjectLoggingController 

type ProjectLoggingController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectLoggingLister
	AddHandler(ctx context.Context, name string, handler ProjectLoggingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectLoggingHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectLoggingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectLoggingHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectLoggingHandlerFunc 

type ProjectLoggingHandlerFunc func(key string, obj *ProjectLogging) (runtime.Object, error)

func NewProjectLoggingLifecycleAdapter 

func NewProjectLoggingLifecycleAdapter(name string, clusterScoped bool, client ProjectLoggingInterface, l ProjectLoggingLifecycle) ProjectLoggingHandlerFunc

type ProjectLoggingInterface 

type ProjectLoggingInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectLogging) (*ProjectLogging, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectLogging, error)
	Get(name string, opts metav1.GetOptions) (*ProjectLogging, error)
	Update(*ProjectLogging) (*ProjectLogging, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectLoggingList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectLoggingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectLoggingController
	AddHandler(ctx context.Context, name string, sync ProjectLoggingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectLoggingHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectLoggingLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectLoggingLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectLoggingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectLoggingHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectLoggingLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectLoggingLifecycle)
}

type ProjectLoggingLifecycle 

type ProjectLoggingLifecycle interface {
	Create(obj *ProjectLogging) (runtime.Object, error)
	Remove(obj *ProjectLogging) (runtime.Object, error)
	Updated(obj *ProjectLogging) (runtime.Object, error)
}

type ProjectLoggingList 

type ProjectLoggingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectLogging `json:"items"`
}

func (*ProjectLoggingList) DeepCopy 

func (in *ProjectLoggingList) DeepCopy() *ProjectLoggingList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectLoggingList.

func (*ProjectLoggingList) DeepCopyInto 

func (in *ProjectLoggingList) DeepCopyInto(out *ProjectLoggingList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectLoggingList) DeepCopyObject 

func (in *ProjectLoggingList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectLoggingLister 

type ProjectLoggingLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectLogging, err error)
	Get(namespace, name string) (*ProjectLogging, error)
}

type ProjectLoggingSpec 

type ProjectLoggingSpec struct {
	LoggingTargets
	LoggingCommonField
	ProjectName string `json:"projectName" norman:"type=reference[project]"`
}

func (*ProjectLoggingSpec) DeepCopy 

func (in *ProjectLoggingSpec) DeepCopy() *ProjectLoggingSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectLoggingSpec.

func (*ProjectLoggingSpec) DeepCopyInto 

func (in *ProjectLoggingSpec) DeepCopyInto(out *ProjectLoggingSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectLoggingSpec) ObjClusterName 

func (p *ProjectLoggingSpec) ObjClusterName() string

type ProjectLoggingStatus 

type ProjectLoggingStatus struct {
	Conditions  []LoggingCondition `json:"conditions,omitempty"`
	AppliedSpec ProjectLoggingSpec `json:"appliedSpec,omitempty"`
}

func (*ProjectLoggingStatus) DeepCopy 

func (in *ProjectLoggingStatus) DeepCopy() *ProjectLoggingStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectLoggingStatus.

func (*ProjectLoggingStatus) DeepCopyInto 

func (in *ProjectLoggingStatus) DeepCopyInto(out *ProjectLoggingStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ProjectLoggingsGetter 

type ProjectLoggingsGetter interface {
	ProjectLoggings(namespace string) ProjectLoggingInterface
}

type ProjectMetricNamesInput 

type ProjectMetricNamesInput struct {
	ProjectName string `json:"projectId" norman:"type=reference[project]"`
}

func (*ProjectMetricNamesInput) DeepCopy 

func (in *ProjectMetricNamesInput) DeepCopy() *ProjectMetricNamesInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectMetricNamesInput.

func (*ProjectMetricNamesInput) DeepCopyInto 

func (in *ProjectMetricNamesInput) DeepCopyInto(out *ProjectMetricNamesInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectMetricNamesInput) ObjClusterName 

func (p *ProjectMetricNamesInput) ObjClusterName() string

type ProjectMonitorGraph 

type ProjectMonitorGraph struct {
	types.Namespaced

	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec ProjectMonitorGraphSpec `json:"spec"`
}

func NewProjectMonitorGraph 

func NewProjectMonitorGraph(namespace, name string, obj ProjectMonitorGraph) *ProjectMonitorGraph

func (*ProjectMonitorGraph) DeepCopy 

func (in *ProjectMonitorGraph) DeepCopy() *ProjectMonitorGraph

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectMonitorGraph.

func (*ProjectMonitorGraph) DeepCopyInto 

func (in *ProjectMonitorGraph) DeepCopyInto(out *ProjectMonitorGraph)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectMonitorGraph) DeepCopyObject 

func (in *ProjectMonitorGraph) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ProjectMonitorGraph) ObjClusterName 

func (p *ProjectMonitorGraph) ObjClusterName() string

type ProjectMonitorGraphChangeHandlerFunc 

type ProjectMonitorGraphChangeHandlerFunc func(obj *ProjectMonitorGraph) (runtime.Object, error)

type ProjectMonitorGraphController 

type ProjectMonitorGraphController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectMonitorGraphLister
	AddHandler(ctx context.Context, name string, handler ProjectMonitorGraphHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectMonitorGraphHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectMonitorGraphHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectMonitorGraphHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectMonitorGraphHandlerFunc 

type ProjectMonitorGraphHandlerFunc func(key string, obj *ProjectMonitorGraph) (runtime.Object, error)

func NewProjectMonitorGraphLifecycleAdapter 

func NewProjectMonitorGraphLifecycleAdapter(name string, clusterScoped bool, client ProjectMonitorGraphInterface, l ProjectMonitorGraphLifecycle) ProjectMonitorGraphHandlerFunc

type ProjectMonitorGraphInterface 

type ProjectMonitorGraphInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectMonitorGraph) (*ProjectMonitorGraph, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectMonitorGraph, error)
	Get(name string, opts metav1.GetOptions) (*ProjectMonitorGraph, error)
	Update(*ProjectMonitorGraph) (*ProjectMonitorGraph, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectMonitorGraphList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectMonitorGraphList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectMonitorGraphController
	AddHandler(ctx context.Context, name string, sync ProjectMonitorGraphHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectMonitorGraphHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectMonitorGraphLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectMonitorGraphLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectMonitorGraphHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectMonitorGraphHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectMonitorGraphLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectMonitorGraphLifecycle)
}

type ProjectMonitorGraphLifecycle 

type ProjectMonitorGraphLifecycle interface {
	Create(obj *ProjectMonitorGraph) (runtime.Object, error)
	Remove(obj *ProjectMonitorGraph) (runtime.Object, error)
	Updated(obj *ProjectMonitorGraph) (runtime.Object, error)
}

type ProjectMonitorGraphList 

type ProjectMonitorGraphList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectMonitorGraph `json:"items"`
}

func (*ProjectMonitorGraphList) DeepCopy 

func (in *ProjectMonitorGraphList) DeepCopy() *ProjectMonitorGraphList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectMonitorGraphList.

func (*ProjectMonitorGraphList) DeepCopyInto 

func (in *ProjectMonitorGraphList) DeepCopyInto(out *ProjectMonitorGraphList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectMonitorGraphList) DeepCopyObject 

func (in *ProjectMonitorGraphList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectMonitorGraphLister 

type ProjectMonitorGraphLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectMonitorGraph, err error)
	Get(namespace, name string) (*ProjectMonitorGraph, error)
}

type ProjectMonitorGraphSpec 

type ProjectMonitorGraphSpec struct {
	ProjectName         string `json:"projectName" norman:"type=reference[project]"`
	ResourceType        string `json:"resourceType,omitempty" norman:"type=enum,options=workload|pod|container"`
	DisplayResourceType string `json:"displayResourceType,omitempty" norman:"type=enum,options=workload|pod|container"`
	CommonMonitorGraphSpec
}

func (*ProjectMonitorGraphSpec) DeepCopy 

func (in *ProjectMonitorGraphSpec) DeepCopy() *ProjectMonitorGraphSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectMonitorGraphSpec.

func (*ProjectMonitorGraphSpec) DeepCopyInto 

func (in *ProjectMonitorGraphSpec) DeepCopyInto(out *ProjectMonitorGraphSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectMonitorGraphSpec) ObjClusterName 

func (p *ProjectMonitorGraphSpec) ObjClusterName() string

type ProjectMonitorGraphsGetter 

type ProjectMonitorGraphsGetter interface {
	ProjectMonitorGraphs(namespace string) ProjectMonitorGraphInterface
}

type ProjectNetworkPoliciesGetter 

type ProjectNetworkPoliciesGetter interface {
	ProjectNetworkPolicies(namespace string) ProjectNetworkPolicyInterface
}

type ProjectNetworkPolicy 

type ProjectNetworkPolicy struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              ProjectNetworkPolicySpec    `json:"spec"`
	Status            *ProjectNetworkPolicyStatus `json:"status"`
}

func NewProjectNetworkPolicy 

func NewProjectNetworkPolicy(namespace, name string, obj ProjectNetworkPolicy) *ProjectNetworkPolicy

func (*ProjectNetworkPolicy) DeepCopy 

func (in *ProjectNetworkPolicy) DeepCopy() *ProjectNetworkPolicy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectNetworkPolicy.

func (*ProjectNetworkPolicy) DeepCopyInto 

func (in *ProjectNetworkPolicy) DeepCopyInto(out *ProjectNetworkPolicy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectNetworkPolicy) DeepCopyObject 

func (in *ProjectNetworkPolicy) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectNetworkPolicyChangeHandlerFunc 

type ProjectNetworkPolicyChangeHandlerFunc func(obj *ProjectNetworkPolicy) (runtime.Object, error)

type ProjectNetworkPolicyController 

type ProjectNetworkPolicyController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectNetworkPolicyLister
	AddHandler(ctx context.Context, name string, handler ProjectNetworkPolicyHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectNetworkPolicyHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectNetworkPolicyHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectNetworkPolicyHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectNetworkPolicyHandlerFunc 

type ProjectNetworkPolicyHandlerFunc func(key string, obj *ProjectNetworkPolicy) (runtime.Object, error)

func NewProjectNetworkPolicyLifecycleAdapter 

func NewProjectNetworkPolicyLifecycleAdapter(name string, clusterScoped bool, client ProjectNetworkPolicyInterface, l ProjectNetworkPolicyLifecycle) ProjectNetworkPolicyHandlerFunc

type ProjectNetworkPolicyInterface 

type ProjectNetworkPolicyInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectNetworkPolicy) (*ProjectNetworkPolicy, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectNetworkPolicy, error)
	Get(name string, opts metav1.GetOptions) (*ProjectNetworkPolicy, error)
	Update(*ProjectNetworkPolicy) (*ProjectNetworkPolicy, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectNetworkPolicyList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectNetworkPolicyList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectNetworkPolicyController
	AddHandler(ctx context.Context, name string, sync ProjectNetworkPolicyHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectNetworkPolicyHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectNetworkPolicyLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectNetworkPolicyLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectNetworkPolicyHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectNetworkPolicyHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectNetworkPolicyLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectNetworkPolicyLifecycle)
}

type ProjectNetworkPolicyLifecycle 

type ProjectNetworkPolicyLifecycle interface {
	Create(obj *ProjectNetworkPolicy) (runtime.Object, error)
	Remove(obj *ProjectNetworkPolicy) (runtime.Object, error)
	Updated(obj *ProjectNetworkPolicy) (runtime.Object, error)
}

type ProjectNetworkPolicyList 

type ProjectNetworkPolicyList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectNetworkPolicy `json:"items"`
}

func (*ProjectNetworkPolicyList) DeepCopy 

func (in *ProjectNetworkPolicyList) DeepCopy() *ProjectNetworkPolicyList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectNetworkPolicyList.

func (*ProjectNetworkPolicyList) DeepCopyInto 

func (in *ProjectNetworkPolicyList) DeepCopyInto(out *ProjectNetworkPolicyList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectNetworkPolicyList) DeepCopyObject 

func (in *ProjectNetworkPolicyList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectNetworkPolicyLister 

type ProjectNetworkPolicyLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectNetworkPolicy, err error)
	Get(namespace, name string) (*ProjectNetworkPolicy, error)
}

type ProjectNetworkPolicySpec 

type ProjectNetworkPolicySpec struct {
	ProjectName string `json:"projectName,omitempty" norman:"required,type=reference[project]"`
	Description string `json:"description"`
}

func (*ProjectNetworkPolicySpec) DeepCopy 

func (in *ProjectNetworkPolicySpec) DeepCopy() *ProjectNetworkPolicySpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectNetworkPolicySpec.

func (*ProjectNetworkPolicySpec) DeepCopyInto 

func (in *ProjectNetworkPolicySpec) DeepCopyInto(out *ProjectNetworkPolicySpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectNetworkPolicySpec) ObjClusterName 

func (p *ProjectNetworkPolicySpec) ObjClusterName() string

type ProjectNetworkPolicyStatus 

type ProjectNetworkPolicyStatus struct {
}

func (*ProjectNetworkPolicyStatus) DeepCopy 

func (in *ProjectNetworkPolicyStatus) DeepCopy() *ProjectNetworkPolicyStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectNetworkPolicyStatus.

func (*ProjectNetworkPolicyStatus) DeepCopyInto 

func (in *ProjectNetworkPolicyStatus) DeepCopyInto(out *ProjectNetworkPolicyStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ProjectResourceQuota 

type ProjectResourceQuota struct {
	Limit     ResourceQuotaLimit `json:"limit,omitempty"`
	UsedLimit ResourceQuotaLimit `json:"usedLimit,omitempty"`
}

func (*ProjectResourceQuota) DeepCopy 

func (in *ProjectResourceQuota) DeepCopy() *ProjectResourceQuota

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectResourceQuota.

func (*ProjectResourceQuota) DeepCopyInto 

func (in *ProjectResourceQuota) DeepCopyInto(out *ProjectResourceQuota)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ProjectRoleTemplateBinding 

type ProjectRoleTemplateBinding struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	UserName           string `json:"userName,omitempty" norman:"noupdate,type=reference[user]"`
	UserPrincipalName  string `json:"userPrincipalName,omitempty" norman:"noupdate,type=reference[principal]"`
	GroupName          string `json:"groupName,omitempty" norman:"noupdate,type=reference[group]"`
	GroupPrincipalName string `json:"groupPrincipalName,omitempty" norman:"noupdate,type=reference[principal]"`
	ProjectName        string `json:"projectName,omitempty" norman:"required,noupdate,type=reference[project]"`
	RoleTemplateName   string `json:"roleTemplateName,omitempty" norman:"required,type=reference[roleTemplate]"`
	ServiceAccount     string `json:"serviceAccount,omitempty" norman:"nocreate,noupdate"`
}

func NewProjectRoleTemplateBinding 

func NewProjectRoleTemplateBinding(namespace, name string, obj ProjectRoleTemplateBinding) *ProjectRoleTemplateBinding

func (*ProjectRoleTemplateBinding) DeepCopy 

func (in *ProjectRoleTemplateBinding) DeepCopy() *ProjectRoleTemplateBinding

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectRoleTemplateBinding.

func (*ProjectRoleTemplateBinding) DeepCopyInto 

func (in *ProjectRoleTemplateBinding) DeepCopyInto(out *ProjectRoleTemplateBinding)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectRoleTemplateBinding) DeepCopyObject 

func (in *ProjectRoleTemplateBinding) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ProjectRoleTemplateBinding) ObjClusterName 

func (p *ProjectRoleTemplateBinding) ObjClusterName() string

type ProjectRoleTemplateBindingChangeHandlerFunc 

type ProjectRoleTemplateBindingChangeHandlerFunc func(obj *ProjectRoleTemplateBinding) (runtime.Object, error)

type ProjectRoleTemplateBindingController 

type ProjectRoleTemplateBindingController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ProjectRoleTemplateBindingLister
	AddHandler(ctx context.Context, name string, handler ProjectRoleTemplateBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectRoleTemplateBindingHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectRoleTemplateBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ProjectRoleTemplateBindingHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectRoleTemplateBindingHandlerFunc 

type ProjectRoleTemplateBindingHandlerFunc func(key string, obj *ProjectRoleTemplateBinding) (runtime.Object, error)

func NewProjectRoleTemplateBindingLifecycleAdapter 

func NewProjectRoleTemplateBindingLifecycleAdapter(name string, clusterScoped bool, client ProjectRoleTemplateBindingInterface, l ProjectRoleTemplateBindingLifecycle) ProjectRoleTemplateBindingHandlerFunc

type ProjectRoleTemplateBindingInterface 

type ProjectRoleTemplateBindingInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ProjectRoleTemplateBinding, error)
	Get(name string, opts metav1.GetOptions) (*ProjectRoleTemplateBinding, error)
	Update(*ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ProjectRoleTemplateBindingList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*ProjectRoleTemplateBindingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ProjectRoleTemplateBindingController
	AddHandler(ctx context.Context, name string, sync ProjectRoleTemplateBindingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ProjectRoleTemplateBindingHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ProjectRoleTemplateBindingLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle ProjectRoleTemplateBindingLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectRoleTemplateBindingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync ProjectRoleTemplateBindingHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectRoleTemplateBindingLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle ProjectRoleTemplateBindingLifecycle)
}

type ProjectRoleTemplateBindingLifecycle 

type ProjectRoleTemplateBindingLifecycle interface {
	Create(obj *ProjectRoleTemplateBinding) (runtime.Object, error)
	Remove(obj *ProjectRoleTemplateBinding) (runtime.Object, error)
	Updated(obj *ProjectRoleTemplateBinding) (runtime.Object, error)
}

type ProjectRoleTemplateBindingList 

type ProjectRoleTemplateBindingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ProjectRoleTemplateBinding `json:"items"`
}

func (*ProjectRoleTemplateBindingList) DeepCopy 

func (in *ProjectRoleTemplateBindingList) DeepCopy() *ProjectRoleTemplateBindingList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectRoleTemplateBindingList.

func (*ProjectRoleTemplateBindingList) DeepCopyInto 

func (in *ProjectRoleTemplateBindingList) DeepCopyInto(out *ProjectRoleTemplateBindingList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectRoleTemplateBindingList) DeepCopyObject 

func (in *ProjectRoleTemplateBindingList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type ProjectRoleTemplateBindingLister 

type ProjectRoleTemplateBindingLister interface {
	List(namespace string, selector labels.Selector) (ret []*ProjectRoleTemplateBinding, err error)
	Get(namespace, name string) (*ProjectRoleTemplateBinding, error)
}

type ProjectRoleTemplateBindingsGetter 

type ProjectRoleTemplateBindingsGetter interface {
	ProjectRoleTemplateBindings(namespace string) ProjectRoleTemplateBindingInterface
}

type ProjectSpec 

type ProjectSpec struct {
	DisplayName                   string                  `json:"displayName,omitempty" norman:"required"`
	Description                   string                  `json:"description"`
	ClusterName                   string                  `json:"clusterName,omitempty" norman:"required,type=reference[cluster]"`
	ResourceQuota                 *ProjectResourceQuota   `json:"resourceQuota,omitempty"`
	NamespaceDefaultResourceQuota *NamespaceResourceQuota `json:"namespaceDefaultResourceQuota,omitempty"`
	ContainerDefaultResourceLimit *ContainerResourceLimit `json:"containerDefaultResourceLimit,omitempty"`
	EnableProjectMonitoring       bool                    `json:"enableProjectMonitoring" norman:"default=false"`
}

func (*ProjectSpec) DeepCopy 

func (in *ProjectSpec) DeepCopy() *ProjectSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectSpec.

func (*ProjectSpec) DeepCopyInto 

func (in *ProjectSpec) DeepCopyInto(out *ProjectSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectSpec) ObjClusterName 

func (p *ProjectSpec) ObjClusterName() string

type ProjectStatus 

type ProjectStatus struct {
	Conditions                    []ProjectCondition `json:"conditions"`
	PodSecurityPolicyTemplateName string             `json:"podSecurityPolicyTemplateId"`
	MonitoringStatus              *MonitoringStatus  `json:"monitoringStatus,omitempty" norman:"nocreate,noupdate"`
}

func (*ProjectStatus) DeepCopy 

func (in *ProjectStatus) DeepCopy() *ProjectStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectStatus.

func (*ProjectStatus) DeepCopyInto 

func (in *ProjectStatus) DeepCopyInto(out *ProjectStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ProjectTestInput 

type ProjectTestInput struct {
	ProjectName string `json:"projectId" norman:"required,type=reference[project]"`
	LoggingTargets
	OutputTags map[string]string `json:"outputTags,omitempty"`
}

func (*ProjectTestInput) DeepCopy 

func (in *ProjectTestInput) DeepCopy() *ProjectTestInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectTestInput.

func (*ProjectTestInput) DeepCopyInto 

func (in *ProjectTestInput) DeepCopyInto(out *ProjectTestInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ProjectTestInput) ObjClusterName 

func (p *ProjectTestInput) ObjClusterName() string

type ProjectsGetter 

type ProjectsGetter interface {
	Projects(namespace string) ProjectInterface
}

type PublicEndpoint 

type PublicEndpoint struct {
	NodeName  string   `json:"nodeName,omitempty" norman:"type=reference[/v3/schemas/node],nocreate,noupdate"`
	Addresses []string `json:"addresses,omitempty" norman:"nocreate,noupdate"`
	Port      int32    `json:"port,omitempty" norman:"nocreate,noupdate"`
	Protocol  string   `json:"protocol,omitempty" norman:"nocreate,noupdate"`
	// for node port service endpoint
	ServiceName string `json:"serviceName,omitempty" norman:"type=reference[service],nocreate,noupdate"`
	// for host port endpoint
	PodName string `json:"podName,omitempty" norman:"type=reference[pod],nocreate,noupdate"`
	// for ingress endpoint. ServiceName, podName, ingressName are mutually exclusive
	IngressName string `json:"ingressName,omitempty" norman:"type=reference[ingress],nocreate,noupdate"`
	// Hostname/path are set for Ingress endpoints
	Hostname string `json:"hostname,omitempty" norman:"nocreate,noupdate"`
	Path     string `json:"path,omitempty" norman:"nocreate,noupdate"`
	// True when endpoint is exposed on every node
	AllNodes bool `json:"allNodes" norman:"nocreate,noupdate"`
}

func (*PublicEndpoint) DeepCopy 

func (in *PublicEndpoint) DeepCopy() *PublicEndpoint

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PublicEndpoint.

func (*PublicEndpoint) DeepCopyInto 

func (in *PublicEndpoint) DeepCopyInto(out *PublicEndpoint)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type QueryClusterGraph 

type QueryClusterGraph struct {
	GraphName string        `json:"graphID" norman:"type=reference[clusterMonitorGraph]"`
	Series    []*TimeSeries `json:"series" norman:"type=array[reference[timeSeries]]"`
}

func (*QueryClusterGraph) DeepCopy 

func (in *QueryClusterGraph) DeepCopy() *QueryClusterGraph

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryClusterGraph.

func (*QueryClusterGraph) DeepCopyInto 

func (in *QueryClusterGraph) DeepCopyInto(out *QueryClusterGraph)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type QueryClusterGraphOutput 

type QueryClusterGraphOutput struct {
	Type string              `json:"type,omitempty"`
	Data []QueryClusterGraph `json:"data,omitempty"`
}

func (*QueryClusterGraphOutput) DeepCopy 

func (in *QueryClusterGraphOutput) DeepCopy() *QueryClusterGraphOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryClusterGraphOutput.

func (*QueryClusterGraphOutput) DeepCopyInto 

func (in *QueryClusterGraphOutput) DeepCopyInto(out *QueryClusterGraphOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type QueryClusterMetricInput 

type QueryClusterMetricInput struct {
	ClusterName string `json:"clusterId" norman:"type=reference[cluster]"`
	CommonQueryMetricInput
}

func (*QueryClusterMetricInput) DeepCopy 

func (in *QueryClusterMetricInput) DeepCopy() *QueryClusterMetricInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryClusterMetricInput.

func (*QueryClusterMetricInput) DeepCopyInto 

func (in *QueryClusterMetricInput) DeepCopyInto(out *QueryClusterMetricInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*QueryClusterMetricInput) ObjClusterName 

func (q *QueryClusterMetricInput) ObjClusterName() string

type QueryGraphInput 

type QueryGraphInput struct {
	From         string            `json:"from,omitempty"`
	To           string            `json:"to,omitempty"`
	Interval     string            `json:"interval,omitempty"`
	MetricParams map[string]string `json:"metricParams,omitempty"`
	Filters      map[string]string `json:"filters,omitempty"`
	IsDetails    bool              `json:"isDetails,omitempty"`
}

func (*QueryGraphInput) DeepCopy 

func (in *QueryGraphInput) DeepCopy() *QueryGraphInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryGraphInput.

func (*QueryGraphInput) DeepCopyInto 

func (in *QueryGraphInput) DeepCopyInto(out *QueryGraphInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type QueryMetricOutput 

type QueryMetricOutput struct {
	Type   string        `json:"type,omitempty"`
	Series []*TimeSeries `json:"series" norman:"type=array[reference[timeSeries]]"`
}

func (*QueryMetricOutput) DeepCopy 

func (in *QueryMetricOutput) DeepCopy() *QueryMetricOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryMetricOutput.

func (*QueryMetricOutput) DeepCopyInto 

func (in *QueryMetricOutput) DeepCopyInto(out *QueryMetricOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type QueryProjectGraph 

type QueryProjectGraph struct {
	GraphName string        `json:"graphID" norman:"type=reference[projectMonitorGraph]"`
	Series    []*TimeSeries `json:"series" norman:"type=array[reference[timeSeries]]"`
}

func (*QueryProjectGraph) DeepCopy 

func (in *QueryProjectGraph) DeepCopy() *QueryProjectGraph

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryProjectGraph.

func (*QueryProjectGraph) DeepCopyInto 

func (in *QueryProjectGraph) DeepCopyInto(out *QueryProjectGraph)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type QueryProjectGraphOutput 

type QueryProjectGraphOutput struct {
	Type string              `json:"type,omitempty"`
	Data []QueryProjectGraph `json:"data,omitempty"`
}

func (*QueryProjectGraphOutput) DeepCopy 

func (in *QueryProjectGraphOutput) DeepCopy() *QueryProjectGraphOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryProjectGraphOutput.

func (*QueryProjectGraphOutput) DeepCopyInto 

func (in *QueryProjectGraphOutput) DeepCopyInto(out *QueryProjectGraphOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type QueryProjectMetricInput 

type QueryProjectMetricInput struct {
	ProjectName string `json:"projectId" norman:"type=reference[project]"`
	CommonQueryMetricInput
}

func (*QueryProjectMetricInput) DeepCopy 

func (in *QueryProjectMetricInput) DeepCopy() *QueryProjectMetricInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryProjectMetricInput.

func (*QueryProjectMetricInput) DeepCopyInto 

func (in *QueryProjectMetricInput) DeepCopyInto(out *QueryProjectMetricInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*QueryProjectMetricInput) ObjClusterName 

func (q *QueryProjectMetricInput) ObjClusterName() string

type Question 

type Question struct {
	Variable          string        `json:"variable,omitempty" yaml:"variable,omitempty"`
	Label             string        `json:"label,omitempty" yaml:"label,omitempty"`
	Description       string        `json:"description,omitempty" yaml:"description,omitempty"`
	Type              string        `json:"type,omitempty" yaml:"type,omitempty"`
	Required          bool          `json:"required,omitempty" yaml:"required,omitempty"`
	Default           string        `json:"default,omitempty" yaml:"default,omitempty"`
	Group             string        `json:"group,omitempty" yaml:"group,omitempty"`
	MinLength         int           `json:"minLength,omitempty" yaml:"min_length,omitempty"`
	MaxLength         int           `json:"maxLength,omitempty" yaml:"max_length,omitempty"`
	Min               int           `json:"min,omitempty" yaml:"min,omitempty"`
	Max               int           `json:"max,omitempty" yaml:"max,omitempty"`
	Options           []string      `json:"options,omitempty" yaml:"options,omitempty"`
	ValidChars        string        `json:"validChars,omitempty" yaml:"valid_chars,omitempty"`
	InvalidChars      string        `json:"invalidChars,omitempty" yaml:"invalid_chars,omitempty"`
	Subquestions      []SubQuestion `json:"subquestions,omitempty" yaml:"subquestions,omitempty"`
	ShowIf            string        `json:"showIf,omitempty" yaml:"show_if,omitempty"`
	ShowSubquestionIf string        `json:"showSubquestionIf,omitempty" yaml:"show_subquestion_if,omitempty"`
	Satisfies         string        `json:"satisfies,omitempty" yaml:"satisfies,omitempty"`
}

func (*Question) DeepCopy 

func (in *Question) DeepCopy() *Question

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Question.

func (*Question) DeepCopyInto 

func (in *Question) DeepCopyInto(out *Question)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RKEAddon 

type RKEAddon struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Template string `yaml:"template" json:"template,omitempty"`
}

func NewRKEAddon 

func NewRKEAddon(namespace, name string, obj RKEAddon) *RKEAddon

func (*RKEAddon) DeepCopy 

func (in *RKEAddon) DeepCopy() *RKEAddon

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEAddon.

func (*RKEAddon) DeepCopyInto 

func (in *RKEAddon) DeepCopyInto(out *RKEAddon)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RKEAddon) DeepCopyObject 

func (in *RKEAddon) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RKEAddonChangeHandlerFunc 

type RKEAddonChangeHandlerFunc func(obj *RKEAddon) (runtime.Object, error)

type RKEAddonController 

type RKEAddonController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() RKEAddonLister
	AddHandler(ctx context.Context, name string, handler RKEAddonHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEAddonHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RKEAddonHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler RKEAddonHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type RKEAddonHandlerFunc 

type RKEAddonHandlerFunc func(key string, obj *RKEAddon) (runtime.Object, error)

func NewRKEAddonLifecycleAdapter 

func NewRKEAddonLifecycleAdapter(name string, clusterScoped bool, client RKEAddonInterface, l RKEAddonLifecycle) RKEAddonHandlerFunc

type RKEAddonInterface 

type RKEAddonInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*RKEAddon) (*RKEAddon, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*RKEAddon, error)
	Get(name string, opts metav1.GetOptions) (*RKEAddon, error)
	Update(*RKEAddon) (*RKEAddon, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*RKEAddonList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*RKEAddonList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() RKEAddonController
	AddHandler(ctx context.Context, name string, sync RKEAddonHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEAddonHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle RKEAddonLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle RKEAddonLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RKEAddonHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync RKEAddonHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RKEAddonLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle RKEAddonLifecycle)
}

type RKEAddonLifecycle 

type RKEAddonLifecycle interface {
	Create(obj *RKEAddon) (runtime.Object, error)
	Remove(obj *RKEAddon) (runtime.Object, error)
	Updated(obj *RKEAddon) (runtime.Object, error)
}

type RKEAddonList 

type RKEAddonList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []RKEAddon `json:"items"`
}

func (*RKEAddonList) DeepCopy 

func (in *RKEAddonList) DeepCopy() *RKEAddonList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEAddonList.

func (*RKEAddonList) DeepCopyInto 

func (in *RKEAddonList) DeepCopyInto(out *RKEAddonList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RKEAddonList) DeepCopyObject 

func (in *RKEAddonList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RKEAddonLister 

type RKEAddonLister interface {
	List(namespace string, selector labels.Selector) (ret []*RKEAddon, err error)
	Get(namespace, name string) (*RKEAddon, error)
}

type RKEAddonsGetter 

type RKEAddonsGetter interface {
	RKEAddons(namespace string) RKEAddonInterface
}

type RKEConfigNode 

type RKEConfigNode struct {
	// Name of the host provisioned via docker machine
	NodeName string `yaml:"nodeName,omitempty" json:"nodeName,omitempty" norman:"type=reference[node]"`
	// IP or FQDN that is fully resolvable and used for SSH communication
	Address string `yaml:"address" json:"address,omitempty"`
	// Port used for SSH communication
	Port string `yaml:"port" json:"port,omitempty"`
	// Optional - Internal address that will be used for components communication
	InternalAddress string `yaml:"internal_address" json:"internalAddress,omitempty"`
	// Node role in kubernetes cluster (controlplane, worker, or etcd)
	Role []string `yaml:"role" json:"role,omitempty" norman:"type=array[enum],options=etcd|worker|controlplane"`
	// Optional - Hostname of the node
	HostnameOverride string `yaml:"hostname_override" json:"hostnameOverride,omitempty"`
	// SSH usesr that will be used by RKE
	User string `yaml:"user" json:"user,omitempty"`
	// Optional - Docker socket on the node that will be used in tunneling
	DockerSocket string `yaml:"docker_socket" json:"dockerSocket,omitempty"`
	// SSH Agent Auth enable
	SSHAgentAuth bool `yaml:"ssh_agent_auth,omitempty" json:"sshAgentAuth,omitempty"`
	// SSH Private Key
	SSHKey string `yaml:"ssh_key" json:"sshKey,omitempty" norman:"type=password"`
	// SSH Private Key Path
	SSHKeyPath string `yaml:"ssh_key_path" json:"sshKeyPath,omitempty"`
	// SSH Certificate
	SSHCert string `yaml:"ssh_cert" json:"sshCert,omitempty"`
	// SSH Certificate Path
	SSHCertPath string `yaml:"ssh_cert_path" json:"sshCertPath,omitempty"`
	// Node Labels
	Labels map[string]string `yaml:"labels" json:"labels,omitempty"`
	// Node Taints
	Taints []RKETaint `yaml:"taints" json:"taints,omitempty"`
}

func (*RKEConfigNode) DeepCopy 

func (in *RKEConfigNode) DeepCopy() *RKEConfigNode

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEConfigNode.

func (*RKEConfigNode) DeepCopyInto 

func (in *RKEConfigNode) DeepCopyInto(out *RKEConfigNode)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RKEConfigNodePlan 

type RKEConfigNodePlan struct {
	// Node address
	Address string `json:"address,omitempty"`
	// map of named processes that should run on the node
	Processes map[string]Process `json:"processes,omitempty"`
	// List of portchecks that should be open on the node
	PortChecks []PortCheck `json:"portChecks,omitempty"`
	// List of files to deploy on the node
	Files []File `json:"files,omitempty"`
	// Node Annotations
	Annotations map[string]string `json:"annotations,omitempty"`
	// Node Labels
	Labels map[string]string `json:"labels,omitempty"`
	// Node Taints
	Taints []RKETaint `json:"taints,omitempty"`
}

func (*RKEConfigNodePlan) DeepCopy 

func (in *RKEConfigNodePlan) DeepCopy() *RKEConfigNodePlan

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEConfigNodePlan.

func (*RKEConfigNodePlan) DeepCopyInto 

func (in *RKEConfigNodePlan) DeepCopyInto(out *RKEConfigNodePlan)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RKEConfigServices 

type RKEConfigServices struct {
	// Etcd Service
	Etcd ETCDService `yaml:"etcd" json:"etcd,omitempty"`
	// KubeAPI Service
	KubeAPI KubeAPIService `yaml:"kube-api" json:"kubeApi,omitempty"`
	// KubeController Service
	KubeController KubeControllerService `yaml:"kube-controller" json:"kubeController,omitempty"`
	// Scheduler Service
	Scheduler SchedulerService `yaml:"scheduler" json:"scheduler,omitempty"`
	// Kubelet Service
	Kubelet KubeletService `yaml:"kubelet" json:"kubelet,omitempty"`
	// KubeProxy Service
	Kubeproxy KubeproxyService `yaml:"kubeproxy" json:"kubeproxy,omitempty"`
}

func (*RKEConfigServices) DeepCopy 

func (in *RKEConfigServices) DeepCopy() *RKEConfigServices

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEConfigServices.

func (*RKEConfigServices) DeepCopyInto 

func (in *RKEConfigServices) DeepCopyInto(out *RKEConfigServices)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RKEK8sServiceOption 

type RKEK8sServiceOption struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	ServiceOptions KubernetesServicesOptions `yaml:"service_options" json:"serviceOptions,omitempty"`
}

func NewRKEK8sServiceOption 

func NewRKEK8sServiceOption(namespace, name string, obj RKEK8sServiceOption) *RKEK8sServiceOption

func (*RKEK8sServiceOption) DeepCopy 

func (in *RKEK8sServiceOption) DeepCopy() *RKEK8sServiceOption

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEK8sServiceOption.

func (*RKEK8sServiceOption) DeepCopyInto 

func (in *RKEK8sServiceOption) DeepCopyInto(out *RKEK8sServiceOption)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RKEK8sServiceOption) DeepCopyObject 

func (in *RKEK8sServiceOption) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RKEK8sServiceOptionChangeHandlerFunc 

type RKEK8sServiceOptionChangeHandlerFunc func(obj *RKEK8sServiceOption) (runtime.Object, error)

type RKEK8sServiceOptionController 

type RKEK8sServiceOptionController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() RKEK8sServiceOptionLister
	AddHandler(ctx context.Context, name string, handler RKEK8sServiceOptionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sServiceOptionHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RKEK8sServiceOptionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler RKEK8sServiceOptionHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type RKEK8sServiceOptionHandlerFunc 

type RKEK8sServiceOptionHandlerFunc func(key string, obj *RKEK8sServiceOption) (runtime.Object, error)

func NewRKEK8sServiceOptionLifecycleAdapter 

func NewRKEK8sServiceOptionLifecycleAdapter(name string, clusterScoped bool, client RKEK8sServiceOptionInterface, l RKEK8sServiceOptionLifecycle) RKEK8sServiceOptionHandlerFunc

type RKEK8sServiceOptionInterface 

type RKEK8sServiceOptionInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*RKEK8sServiceOption) (*RKEK8sServiceOption, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*RKEK8sServiceOption, error)
	Get(name string, opts metav1.GetOptions) (*RKEK8sServiceOption, error)
	Update(*RKEK8sServiceOption) (*RKEK8sServiceOption, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*RKEK8sServiceOptionList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*RKEK8sServiceOptionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() RKEK8sServiceOptionController
	AddHandler(ctx context.Context, name string, sync RKEK8sServiceOptionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sServiceOptionHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle RKEK8sServiceOptionLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle RKEK8sServiceOptionLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RKEK8sServiceOptionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync RKEK8sServiceOptionHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RKEK8sServiceOptionLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle RKEK8sServiceOptionLifecycle)
}

type RKEK8sServiceOptionLifecycle 

type RKEK8sServiceOptionLifecycle interface {
	Create(obj *RKEK8sServiceOption) (runtime.Object, error)
	Remove(obj *RKEK8sServiceOption) (runtime.Object, error)
	Updated(obj *RKEK8sServiceOption) (runtime.Object, error)
}

type RKEK8sServiceOptionList 

type RKEK8sServiceOptionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []RKEK8sServiceOption `json:"items"`
}

func (*RKEK8sServiceOptionList) DeepCopy 

func (in *RKEK8sServiceOptionList) DeepCopy() *RKEK8sServiceOptionList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEK8sServiceOptionList.

func (*RKEK8sServiceOptionList) DeepCopyInto 

func (in *RKEK8sServiceOptionList) DeepCopyInto(out *RKEK8sServiceOptionList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RKEK8sServiceOptionList) DeepCopyObject 

func (in *RKEK8sServiceOptionList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RKEK8sServiceOptionLister 

type RKEK8sServiceOptionLister interface {
	List(namespace string, selector labels.Selector) (ret []*RKEK8sServiceOption, err error)
	Get(namespace, name string) (*RKEK8sServiceOption, error)
}

type RKEK8sServiceOptionsGetter 

type RKEK8sServiceOptionsGetter interface {
	RKEK8sServiceOptions(namespace string) RKEK8sServiceOptionInterface
}

type RKEK8sSystemImage 

type RKEK8sSystemImage struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	SystemImages RKESystemImages `yaml:"system_images" json:"systemImages,omitempty"`
}

func NewRKEK8sSystemImage 

func NewRKEK8sSystemImage(namespace, name string, obj RKEK8sSystemImage) *RKEK8sSystemImage

func (*RKEK8sSystemImage) DeepCopy 

func (in *RKEK8sSystemImage) DeepCopy() *RKEK8sSystemImage

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEK8sSystemImage.

func (*RKEK8sSystemImage) DeepCopyInto 

func (in *RKEK8sSystemImage) DeepCopyInto(out *RKEK8sSystemImage)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RKEK8sSystemImage) DeepCopyObject 

func (in *RKEK8sSystemImage) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RKEK8sSystemImageChangeHandlerFunc 

type RKEK8sSystemImageChangeHandlerFunc func(obj *RKEK8sSystemImage) (runtime.Object, error)

type RKEK8sSystemImageController 

type RKEK8sSystemImageController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() RKEK8sSystemImageLister
	AddHandler(ctx context.Context, name string, handler RKEK8sSystemImageHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sSystemImageHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RKEK8sSystemImageHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler RKEK8sSystemImageHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type RKEK8sSystemImageHandlerFunc 

type RKEK8sSystemImageHandlerFunc func(key string, obj *RKEK8sSystemImage) (runtime.Object, error)

func NewRKEK8sSystemImageLifecycleAdapter 

func NewRKEK8sSystemImageLifecycleAdapter(name string, clusterScoped bool, client RKEK8sSystemImageInterface, l RKEK8sSystemImageLifecycle) RKEK8sSystemImageHandlerFunc

type RKEK8sSystemImageInterface 

type RKEK8sSystemImageInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*RKEK8sSystemImage) (*RKEK8sSystemImage, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*RKEK8sSystemImage, error)
	Get(name string, opts metav1.GetOptions) (*RKEK8sSystemImage, error)
	Update(*RKEK8sSystemImage) (*RKEK8sSystemImage, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*RKEK8sSystemImageList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*RKEK8sSystemImageList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() RKEK8sSystemImageController
	AddHandler(ctx context.Context, name string, sync RKEK8sSystemImageHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sSystemImageHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle RKEK8sSystemImageLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle RKEK8sSystemImageLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RKEK8sSystemImageHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync RKEK8sSystemImageHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RKEK8sSystemImageLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle RKEK8sSystemImageLifecycle)
}

type RKEK8sSystemImageLifecycle 

type RKEK8sSystemImageLifecycle interface {
	Create(obj *RKEK8sSystemImage) (runtime.Object, error)
	Remove(obj *RKEK8sSystemImage) (runtime.Object, error)
	Updated(obj *RKEK8sSystemImage) (runtime.Object, error)
}

type RKEK8sSystemImageList 

type RKEK8sSystemImageList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []RKEK8sSystemImage `json:"items"`
}

func (*RKEK8sSystemImageList) DeepCopy 

func (in *RKEK8sSystemImageList) DeepCopy() *RKEK8sSystemImageList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEK8sSystemImageList.

func (*RKEK8sSystemImageList) DeepCopyInto 

func (in *RKEK8sSystemImageList) DeepCopyInto(out *RKEK8sSystemImageList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RKEK8sSystemImageList) DeepCopyObject 

func (in *RKEK8sSystemImageList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RKEK8sSystemImageLister 

type RKEK8sSystemImageLister interface {
	List(namespace string, selector labels.Selector) (ret []*RKEK8sSystemImage, err error)
	Get(namespace, name string) (*RKEK8sSystemImage, error)
}

type RKEK8sSystemImagesGetter 

type RKEK8sSystemImagesGetter interface {
	RKEK8sSystemImages(namespace string) RKEK8sSystemImageInterface
}

type RKEPlan 

type RKEPlan struct {
	// List of node Plans
	Nodes []RKEConfigNodePlan `json:"nodes,omitempty"`
}

func (*RKEPlan) DeepCopy 

func (in *RKEPlan) DeepCopy() *RKEPlan

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEPlan.

func (*RKEPlan) DeepCopyInto 

func (in *RKEPlan) DeepCopyInto(out *RKEPlan)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RKESystemImages 

type RKESystemImages struct {
	// etcd image
	Etcd string `yaml:"etcd" json:"etcd,omitempty"`
	// Alpine image
	Alpine string `yaml:"alpine" json:"alpine,omitempty"`
	// rke-nginx-proxy image
	NginxProxy string `yaml:"nginx_proxy" json:"nginxProxy,omitempty"`
	// rke-cert-deployer image
	CertDownloader string `yaml:"cert_downloader" json:"certDownloader,omitempty"`
	// rke-service-sidekick image
	KubernetesServicesSidecar string `yaml:"kubernetes_services_sidecar" json:"kubernetesServicesSidecar,omitempty"`
	// KubeDNS image
	KubeDNS string `yaml:"kubedns" json:"kubedns,omitempty"`
	// DNSMasq image
	DNSmasq string `yaml:"dnsmasq" json:"dnsmasq,omitempty"`
	// KubeDNS side car image
	KubeDNSSidecar string `yaml:"kubedns_sidecar" json:"kubednsSidecar,omitempty"`
	// KubeDNS autoscaler image
	KubeDNSAutoscaler string `yaml:"kubedns_autoscaler" json:"kubednsAutoscaler,omitempty"`
	// CoreDNS image
	CoreDNS string `yaml:"coredns" json:"coredns,omitempty"`
	// CoreDNS autoscaler image
	CoreDNSAutoscaler string `yaml:"coredns_autoscaler" json:"corednsAutoscaler,omitempty"`
	// Nodelocal image
	Nodelocal string `yaml:"nodelocal" json:"nodelocal,omitempty"`
	// Kubernetes image
	Kubernetes string `yaml:"kubernetes" json:"kubernetes,omitempty"`
	// Flannel image
	Flannel string `yaml:"flannel" json:"flannel,omitempty"`
	// Flannel CNI image
	FlannelCNI string `yaml:"flannel_cni" json:"flannelCni,omitempty"`
	// Calico Node image
	CalicoNode string `yaml:"calico_node" json:"calicoNode,omitempty"`
	// Calico CNI image
	CalicoCNI string `yaml:"calico_cni" json:"calicoCni,omitempty"`
	// Calico Controllers image
	CalicoControllers string `yaml:"calico_controllers" json:"calicoControllers,omitempty"`
	// Calicoctl image
	CalicoCtl string `yaml:"calico_ctl" json:"calicoCtl,omitempty"`
	//CalicoFlexVol image
	CalicoFlexVol string `yaml:"calico_flexvol" json:"calicoFlexVol,omitempty"`
	// Canal Node Image
	CanalNode string `yaml:"canal_node" json:"canalNode,omitempty"`
	// Canal CNI image
	CanalCNI string `yaml:"canal_cni" json:"canalCni,omitempty"`
	//CanalFlannel image
	CanalFlannel string `yaml:"canal_flannel" json:"canalFlannel,omitempty"`
	//CanalFlexVol image
	CanalFlexVol string `yaml:"canal_flexvol" json:"canalFlexVol,omitempty"`
	//Weave Node image
	WeaveNode string `yaml:"weave_node" json:"weaveNode,omitempty"`
	// Weave CNI image
	WeaveCNI string `yaml:"weave_cni" json:"weaveCni,omitempty"`
	// Pod infra container image
	PodInfraContainer string `yaml:"pod_infra_container" json:"podInfraContainer,omitempty"`
	// Ingress Controller image
	Ingress string `yaml:"ingress" json:"ingress,omitempty"`
	// Ingress Controller Backend image
	IngressBackend string `yaml:"ingress_backend" json:"ingressBackend,omitempty"`
	// Metrics Server image
	MetricsServer string `yaml:"metrics_server" json:"metricsServer,omitempty"`
	// Pod infra container image for Windows
	WindowsPodInfraContainer string `yaml:"windows_pod_infra_container" json:"windowsPodInfraContainer,omitempty"`
}

func (*RKESystemImages) DeepCopy 

func (in *RKESystemImages) DeepCopy() *RKESystemImages

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKESystemImages.

func (*RKESystemImages) DeepCopyInto 

func (in *RKESystemImages) DeepCopyInto(out *RKESystemImages)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RKETaint 

type RKETaint struct {
	Key       string         `json:"key,omitempty" yaml:"key"`
	Value     string         `json:"value,omitempty" yaml:"value"`
	Effect    v1.TaintEffect `json:"effect,omitempty" yaml:"effect"`
	TimeAdded *metav1.Time   `json:"timeAdded,omitempty" yaml:"timeAdded,omitempty"`
}

func (*RKETaint) DeepCopy 

func (in *RKETaint) DeepCopy() *RKETaint

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKETaint.

func (*RKETaint) DeepCopyInto 

func (in *RKETaint) DeepCopyInto(out *RKETaint)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RancherKubernetesEngineConfig 

type RancherKubernetesEngineConfig struct {
	// Kubernetes nodes
	Nodes []RKEConfigNode `yaml:"nodes" json:"nodes,omitempty"`
	// Kubernetes components
	Services RKEConfigServices `yaml:"services" json:"services,omitempty"`
	// Network configuration used in the kubernetes cluster (flannel, calico)
	Network NetworkConfig `yaml:"network" json:"network,omitempty"`
	// Authentication configuration used in the cluster (default: x509)
	Authentication AuthnConfig `yaml:"authentication" json:"authentication,omitempty"`
	// YAML manifest for user provided addons to be deployed on the cluster
	Addons string `yaml:"addons" json:"addons,omitempty"`
	// List of urls or paths for addons
	AddonsInclude []string `yaml:"addons_include" json:"addonsInclude,omitempty"`
	// List of images used internally for proxy, cert downlaod and kubedns
	SystemImages RKESystemImages `yaml:"system_images" json:"systemImages,omitempty"`
	// SSH Private Key Path
	SSHKeyPath string `yaml:"ssh_key_path" json:"sshKeyPath,omitempty" norman:"nocreate,noupdate"`
	// SSH Certificate Path
	SSHCertPath string `yaml:"ssh_cert_path" json:"sshCertPath,omitempty" norman:"nocreate,noupdate"`
	// SSH Agent Auth enable
	SSHAgentAuth bool `yaml:"ssh_agent_auth" json:"sshAgentAuth"`
	// Authorization mode configuration used in the cluster
	Authorization AuthzConfig `yaml:"authorization" json:"authorization,omitempty"`
	// Enable/disable strict docker version checking
	IgnoreDockerVersion *bool `yaml:"ignore_docker_version" json:"ignoreDockerVersion" norman:"default=true"`
	// Kubernetes version to use (if kubernetes image is specifed, image version takes precedence)
	Version string `yaml:"kubernetes_version" json:"kubernetesVersion,omitempty"`
	// List of private registries and their credentials
	PrivateRegistries []PrivateRegistry `yaml:"private_registries" json:"privateRegistries,omitempty"`
	// Ingress controller used in the cluster
	Ingress IngressConfig `yaml:"ingress" json:"ingress,omitempty"`
	// Cluster Name used in the kube config
	ClusterName string `yaml:"cluster_name" json:"clusterName,omitempty"`
	// Cloud Provider options
	CloudProvider CloudProvider `yaml:"cloud_provider" json:"cloudProvider,omitempty"`
	// kubernetes directory path
	PrefixPath string `yaml:"prefix_path" json:"prefixPath,omitempty"`
	// kubernetes directory path for windows
	WindowsPrefixPath string `yaml:"win_prefix_path" json:"winPrefixPath,omitempty"`
	// Timeout in seconds for status check on addon deployment jobs
	AddonJobTimeout int `yaml:"addon_job_timeout" json:"addonJobTimeout,omitempty" norman:"default=30"`
	// Bastion/Jump Host configuration
	BastionHost BastionHost `yaml:"bastion_host" json:"bastionHost,omitempty"`
	// Monitoring Config
	Monitoring MonitoringConfig `yaml:"monitoring" json:"monitoring,omitempty"`
	// RestoreCluster flag
	Restore RestoreConfig `yaml:"restore" json:"restore,omitempty"`
	// Rotating Certificates Option
	RotateCertificates *RotateCertificates `yaml:"rotate_certificates,omitempty" json:"rotateCertificates,omitempty"`
	// DNS Config
	DNS *DNSConfig `yaml:"dns" json:"dns,omitempty"`
	// Upgrade Strategy for the cluster
	UpgradeStrategy *NodeUpgradeStrategy `yaml:"upgrade_strategy,omitempty" json:"upgradeStrategy,omitempty"`
}

func (*RancherKubernetesEngineConfig) DeepCopy 

func (in *RancherKubernetesEngineConfig) DeepCopy() *RancherKubernetesEngineConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RancherKubernetesEngineConfig.

func (*RancherKubernetesEngineConfig) DeepCopyInto 

func (in *RancherKubernetesEngineConfig) DeepCopyInto(out *RancherKubernetesEngineConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RancherKubernetesEngineConfig) ObjClusterName 

func (r *RancherKubernetesEngineConfig) ObjClusterName() string

type Recipient 

type Recipient struct {
	Recipient    string `json:"recipient,omitempty"`
	NotifierName string `json:"notifierName,omitempty" norman:"required,type=reference[notifier]"`
	NotifierType string `json:"notifierType,omitempty" norman:"required,options=slack|email|pagerduty|webhook|wechat|dingtalk|msteams"`
}

func (*Recipient) DeepCopy 

func (in *Recipient) DeepCopy() *Recipient

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Recipient.

func (*Recipient) DeepCopyInto 

func (in *Recipient) DeepCopyInto(out *Recipient)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ResourceQuotaLimit 

type ResourceQuotaLimit struct {
	Pods                   string `json:"pods,omitempty"`
	Services               string `json:"services,omitempty"`
	ReplicationControllers string `json:"replicationControllers,omitempty"`
	Secrets                string `json:"secrets,omitempty"`
	ConfigMaps             string `json:"configMaps,omitempty"`
	PersistentVolumeClaims string `json:"persistentVolumeClaims,omitempty"`
	ServicesNodePorts      string `json:"servicesNodePorts,omitempty"`
	ServicesLoadBalancers  string `json:"servicesLoadBalancers,omitempty"`
	RequestsCPU            string `json:"requestsCpu,omitempty"`
	RequestsMemory         string `json:"requestsMemory,omitempty"`
	RequestsStorage        string `json:"requestsStorage,omitempty"`
	LimitsCPU              string `json:"limitsCpu,omitempty"`
	LimitsMemory           string `json:"limitsMemory,omitempty"`
}

func (*ResourceQuotaLimit) DeepCopy 

func (in *ResourceQuotaLimit) DeepCopy() *ResourceQuotaLimit

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceQuotaLimit.

func (*ResourceQuotaLimit) DeepCopyInto 

func (in *ResourceQuotaLimit) DeepCopyInto(out *ResourceQuotaLimit)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RestoreConfig 

type RestoreConfig struct {
	Restore      bool   `yaml:"restore" json:"restore,omitempty"`
	SnapshotName string `yaml:"snapshot_name" json:"snapshotName,omitempty"`
}

func (*RestoreConfig) DeepCopy 

func (in *RestoreConfig) DeepCopy() *RestoreConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RestoreConfig.

func (*RestoreConfig) DeepCopyInto 

func (in *RestoreConfig) DeepCopyInto(out *RestoreConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RestoreFromEtcdBackupInput 

type RestoreFromEtcdBackupInput struct {
	EtcdBackupName   string `json:"etcdBackupName,omitempty" norman:"type=reference[etcdBackup]"`
	RestoreRkeConfig string `json:"restoreRkeConfig,omitempty"`
}

func (*RestoreFromEtcdBackupInput) DeepCopy 

func (in *RestoreFromEtcdBackupInput) DeepCopy() *RestoreFromEtcdBackupInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RestoreFromEtcdBackupInput.

func (*RestoreFromEtcdBackupInput) DeepCopyInto 

func (in *RestoreFromEtcdBackupInput) DeepCopyInto(out *RestoreFromEtcdBackupInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RoleTemplate 

type RoleTemplate struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	DisplayName           string              `json:"displayName,omitempty" norman:"required"`
	Description           string              `json:"description"`
	Rules                 []rbacv1.PolicyRule `json:"rules,omitempty"`
	Builtin               bool                `json:"builtin" norman:"nocreate,noupdate"`
	External              bool                `json:"external"`
	Hidden                bool                `json:"hidden"`
	Locked                bool                `json:"locked,omitempty" norman:"type=boolean"`
	ClusterCreatorDefault bool                `json:"clusterCreatorDefault,omitempty" norman:"required"`
	ProjectCreatorDefault bool                `json:"projectCreatorDefault,omitempty" norman:"required"`
	Context               string              `json:"context" norman:"type=string,options=project|cluster"`
	RoleTemplateNames     []string            `json:"roleTemplateNames,omitempty" norman:"type=array[reference[roleTemplate]]"`
	Administrative        bool                `json:"administrative,omitempty"`
}

func NewRoleTemplate 

func NewRoleTemplate(namespace, name string, obj RoleTemplate) *RoleTemplate

func (*RoleTemplate) DeepCopy 

func (in *RoleTemplate) DeepCopy() *RoleTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RoleTemplate.

func (*RoleTemplate) DeepCopyInto 

func (in *RoleTemplate) DeepCopyInto(out *RoleTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RoleTemplate) DeepCopyObject 

func (in *RoleTemplate) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RoleTemplateChangeHandlerFunc 

type RoleTemplateChangeHandlerFunc func(obj *RoleTemplate) (runtime.Object, error)

type RoleTemplateController 

type RoleTemplateController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() RoleTemplateLister
	AddHandler(ctx context.Context, name string, handler RoleTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RoleTemplateHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RoleTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler RoleTemplateHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type RoleTemplateHandlerFunc 

type RoleTemplateHandlerFunc func(key string, obj *RoleTemplate) (runtime.Object, error)

func NewRoleTemplateLifecycleAdapter 

func NewRoleTemplateLifecycleAdapter(name string, clusterScoped bool, client RoleTemplateInterface, l RoleTemplateLifecycle) RoleTemplateHandlerFunc

type RoleTemplateInterface 

type RoleTemplateInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*RoleTemplate) (*RoleTemplate, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*RoleTemplate, error)
	Get(name string, opts metav1.GetOptions) (*RoleTemplate, error)
	Update(*RoleTemplate) (*RoleTemplate, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*RoleTemplateList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*RoleTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() RoleTemplateController
	AddHandler(ctx context.Context, name string, sync RoleTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RoleTemplateHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle RoleTemplateLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle RoleTemplateLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RoleTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync RoleTemplateHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RoleTemplateLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle RoleTemplateLifecycle)
}

type RoleTemplateLifecycle 

type RoleTemplateLifecycle interface {
	Create(obj *RoleTemplate) (runtime.Object, error)
	Remove(obj *RoleTemplate) (runtime.Object, error)
	Updated(obj *RoleTemplate) (runtime.Object, error)
}

type RoleTemplateList 

type RoleTemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []RoleTemplate `json:"items"`
}

func (*RoleTemplateList) DeepCopy 

func (in *RoleTemplateList) DeepCopy() *RoleTemplateList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RoleTemplateList.

func (*RoleTemplateList) DeepCopyInto 

func (in *RoleTemplateList) DeepCopyInto(out *RoleTemplateList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RoleTemplateList) DeepCopyObject 

func (in *RoleTemplateList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RoleTemplateLister 

type RoleTemplateLister interface {
	List(namespace string, selector labels.Selector) (ret []*RoleTemplate, err error)
	Get(namespace, name string) (*RoleTemplate, error)
}

type RoleTemplatesGetter 

type RoleTemplatesGetter interface {
	RoleTemplates(namespace string) RoleTemplateInterface
}

type RollingUpdate 

type RollingUpdate struct {
	BatchSize int `json:"batchSize,omitempty"`
	Interval  int `json:"interval,omitempty"`
}

func (*RollingUpdate) DeepCopy 

func (in *RollingUpdate) DeepCopy() *RollingUpdate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RollingUpdate.

func (*RollingUpdate) DeepCopyInto 

func (in *RollingUpdate) DeepCopyInto(out *RollingUpdate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RotateCertificateInput 

type RotateCertificateInput struct {
	CACertificates bool     `json:"caCertificates,omitempty"`
	Services       []string `` /* 130-byte string literal not displayed */
}

func (*RotateCertificateInput) DeepCopy 

func (in *RotateCertificateInput) DeepCopy() *RotateCertificateInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RotateCertificateInput.

func (*RotateCertificateInput) DeepCopyInto 

func (in *RotateCertificateInput) DeepCopyInto(out *RotateCertificateInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RotateCertificateOutput 

type RotateCertificateOutput struct {
	Message string `json:"message,omitempty"`
}

func (*RotateCertificateOutput) DeepCopy 

func (in *RotateCertificateOutput) DeepCopy() *RotateCertificateOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RotateCertificateOutput.

func (*RotateCertificateOutput) DeepCopyInto 

func (in *RotateCertificateOutput) DeepCopyInto(out *RotateCertificateOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RotateCertificates 

type RotateCertificates struct {
	// Rotate CA Certificates
	CACertificates bool `json:"caCertificates,omitempty"`
	// Services to rotate their certs
	Services []string `` /* 130-byte string literal not displayed */
}

func (*RotateCertificates) DeepCopy 

func (in *RotateCertificates) DeepCopy() *RotateCertificates

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RotateCertificates.

func (*RotateCertificates) DeepCopyInto 

func (in *RotateCertificates) DeepCopyInto(out *RotateCertificates)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Route53ProviderConfig 

type Route53ProviderConfig struct {
	AccessKey         string            `json:"accessKey" norman:"notnullable,required,minLength=1"`
	SecretKey         string            `json:"secretKey" norman:"notnullable,required,minLength=1,type=password"`
	CredentialsPath   string            `json:"credentialsPath" norman:"default=/.aws"`
	RoleArn           string            `json:"roleArn,omitempty"`
	Region            string            `json:"region" norman:"default=us-east-1"`
	ZoneType          string            `json:"zoneType" norman:"default=public"`
	AdditionalOptions map[string]string `json:"additionalOptions,omitempty"`
}

func (*Route53ProviderConfig) DeepCopy 

func (in *Route53ProviderConfig) DeepCopy() *Route53ProviderConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Route53ProviderConfig.

func (*Route53ProviderConfig) DeepCopyInto 

func (in *Route53ProviderConfig) DeepCopyInto(out *Route53ProviderConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RouteOpenstackOpts 

type RouteOpenstackOpts struct {
	RouterID string `json:"router-id" yaml:"router-id" ini:"router-id,omitempty"` // required
}

func (*RouteOpenstackOpts) DeepCopy 

func (in *RouteOpenstackOpts) DeepCopy() *RouteOpenstackOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteOpenstackOpts.

func (*RouteOpenstackOpts) DeepCopyInto 

func (in *RouteOpenstackOpts) DeepCopyInto(out *RouteOpenstackOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type S3BackupConfig 

type S3BackupConfig struct {
	// Access key ID
	AccessKey string `yaml:"access_key" json:"accessKey,omitempty"`
	// Secret access key
	SecretKey string `yaml:"secret_key" json:"secretKey,omitempty" norman:"type=password" `
	// name of the bucket to use for backup
	BucketName string `yaml:"bucket_name" json:"bucketName,omitempty"`
	// AWS Region, AWS spcific
	Region string `yaml:"region" json:"region,omitempty"`
	// Endpoint is used if this is not an AWS API
	Endpoint string `yaml:"endpoint" json:"endpoint"`
	// CustomCA is used to connect to custom s3 endpoints
	CustomCA string `yaml:"custom_ca" json:"customCa,omitempty"`
	// Folder to place the files
	Folder string `yaml:"folder" json:"folder,omitempty"`
}

func (*S3BackupConfig) DeepCopy 

func (in *S3BackupConfig) DeepCopy() *S3BackupConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new S3BackupConfig.

func (*S3BackupConfig) DeepCopyInto 

func (in *S3BackupConfig) DeepCopyInto(out *S3BackupConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SMTPConfig 

type SMTPConfig struct {
	Host             string `json:"host,omitempty" norman:"required,type=hostname"`
	Port             int    `json:"port,omitempty" norman:"required,min=1,max=65535,default=587"`
	Username         string `json:"username,omitempty"`
	Password         string `json:"password,omitempty" norman:"type=password"`
	Sender           string `json:"sender,omitempty" norman:"required"`
	DefaultRecipient string `json:"defaultRecipient,omitempty" norman:"required"`
	TLS              *bool  `json:"tls,omitempty" norman:"required,default=true"`
}

func (*SMTPConfig) DeepCopy 

func (in *SMTPConfig) DeepCopy() *SMTPConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SMTPConfig.

func (*SMTPConfig) DeepCopyInto 

func (in *SMTPConfig) DeepCopyInto(out *SMTPConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SamlConfig 

type SamlConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	AuthConfig        `json:",inline" mapstructure:",squash"`

	IDPMetadataContent string `json:"idpMetadataContent" norman:"required"`
	SpCert             string `json:"spCert"             norman:"required"`
	SpKey              string `json:"spKey"              norman:"required,type=password"`
	GroupsField        string `json:"groupsField"        norman:"required"`
	DisplayNameField   string `json:"displayNameField"   norman:"required"`
	UserNameField      string `json:"userNameField"      norman:"required"`
	UIDField           string `json:"uidField"           norman:"required"`
	RancherAPIHost     string `json:"rancherApiHost"     norman:"required"`
}

func (*SamlConfig) DeepCopy 

func (in *SamlConfig) DeepCopy() *SamlConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SamlConfig.

func (*SamlConfig) DeepCopyInto 

func (in *SamlConfig) DeepCopyInto(out *SamlConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*SamlConfig) DeepCopyObject 

func (in *SamlConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type SamlConfigTestInput 

type SamlConfigTestInput struct {
	FinalRedirectURL string `json:"finalRedirectUrl"`
}

func (*SamlConfigTestInput) DeepCopy 

func (in *SamlConfigTestInput) DeepCopy() *SamlConfigTestInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SamlConfigTestInput.

func (*SamlConfigTestInput) DeepCopyInto 

func (in *SamlConfigTestInput) DeepCopyInto(out *SamlConfigTestInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SamlConfigTestOutput 

type SamlConfigTestOutput struct {
	IdpRedirectURL string `json:"idpRedirectUrl"`
}

func (*SamlConfigTestOutput) DeepCopy 

func (in *SamlConfigTestOutput) DeepCopy() *SamlConfigTestOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SamlConfigTestOutput.

func (*SamlConfigTestOutput) DeepCopyInto 

func (in *SamlConfigTestOutput) DeepCopyInto(out *SamlConfigTestOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SamlToken 

type SamlToken struct {
	types.Namespaced
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Token     string `json:"token" norman:"writeOnly,noupdate"`
	ExpiresAt string `json:"expiresAt"`
}

func NewSamlToken 

func NewSamlToken(namespace, name string, obj SamlToken) *SamlToken

func (*SamlToken) DeepCopy 

func (in *SamlToken) DeepCopy() *SamlToken

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SamlToken.

func (*SamlToken) DeepCopyInto 

func (in *SamlToken) DeepCopyInto(out *SamlToken)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*SamlToken) DeepCopyObject 

func (in *SamlToken) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type SamlTokenChangeHandlerFunc 

type SamlTokenChangeHandlerFunc func(obj *SamlToken) (runtime.Object, error)

type SamlTokenController 

type SamlTokenController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() SamlTokenLister
	AddHandler(ctx context.Context, name string, handler SamlTokenHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync SamlTokenHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SamlTokenHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler SamlTokenHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type SamlTokenHandlerFunc 

type SamlTokenHandlerFunc func(key string, obj *SamlToken) (runtime.Object, error)

func NewSamlTokenLifecycleAdapter 

func NewSamlTokenLifecycleAdapter(name string, clusterScoped bool, client SamlTokenInterface, l SamlTokenLifecycle) SamlTokenHandlerFunc

type SamlTokenInterface 

type SamlTokenInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*SamlToken) (*SamlToken, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*SamlToken, error)
	Get(name string, opts metav1.GetOptions) (*SamlToken, error)
	Update(*SamlToken) (*SamlToken, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*SamlTokenList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*SamlTokenList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() SamlTokenController
	AddHandler(ctx context.Context, name string, sync SamlTokenHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync SamlTokenHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle SamlTokenLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle SamlTokenLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SamlTokenHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync SamlTokenHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SamlTokenLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle SamlTokenLifecycle)
}

type SamlTokenLifecycle 

type SamlTokenLifecycle interface {
	Create(obj *SamlToken) (runtime.Object, error)
	Remove(obj *SamlToken) (runtime.Object, error)
	Updated(obj *SamlToken) (runtime.Object, error)
}

type SamlTokenList 

type SamlTokenList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []SamlToken `json:"items"`
}

func (*SamlTokenList) DeepCopy 

func (in *SamlTokenList) DeepCopy() *SamlTokenList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SamlTokenList.

func (*SamlTokenList) DeepCopyInto 

func (in *SamlTokenList) DeepCopyInto(out *SamlTokenList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*SamlTokenList) DeepCopyObject 

func (in *SamlTokenList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type SamlTokenLister 

type SamlTokenLister interface {
	List(namespace string, selector labels.Selector) (ret []*SamlToken, err error)
	Get(namespace, name string) (*SamlToken, error)
}

type SamlTokensGetter 

type SamlTokensGetter interface {
	SamlTokens(namespace string) SamlTokenInterface
}

type SaveAsTemplateInput 

type SaveAsTemplateInput struct {
	ClusterTemplateName         string `json:"clusterTemplateName,omitempty"`
	ClusterTemplateRevisionName string `json:"clusterTemplateRevisionName,omitempty"`
}

func (*SaveAsTemplateInput) DeepCopy 

func (in *SaveAsTemplateInput) DeepCopy() *SaveAsTemplateInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SaveAsTemplateInput.

func (*SaveAsTemplateInput) DeepCopyInto 

func (in *SaveAsTemplateInput) DeepCopyInto(out *SaveAsTemplateInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SaveAsTemplateOutput 

type SaveAsTemplateOutput struct {
	ClusterTemplateName         string `json:"clusterTemplateName,omitempty"`
	ClusterTemplateRevisionName string `json:"clusterTemplateRevisionName,omitempty"`
}

func (*SaveAsTemplateOutput) DeepCopy 

func (in *SaveAsTemplateOutput) DeepCopy() *SaveAsTemplateOutput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SaveAsTemplateOutput.

func (*SaveAsTemplateOutput) DeepCopyInto 

func (in *SaveAsTemplateOutput) DeepCopyInto(out *SaveAsTemplateOutput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ScheduledClusterScan 

type ScheduledClusterScan struct {
	// Enable or disable scheduled scans
	Enabled        bool                        `yaml:"enabled" json:"enabled,omitempty" norman:"default=false"`
	ScheduleConfig *ScheduledClusterScanConfig `yaml:"schedule_config" json:"scheduleConfig,omitempty"`
	ScanConfig     *ClusterScanConfig          `yaml:"scan_config,omitempty" json:"scanConfig,omitempty"`
}

func (*ScheduledClusterScan) DeepCopy 

func (in *ScheduledClusterScan) DeepCopy() *ScheduledClusterScan

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScheduledClusterScan.

func (*ScheduledClusterScan) DeepCopyInto 

func (in *ScheduledClusterScan) DeepCopyInto(out *ScheduledClusterScan)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ScheduledClusterScanConfig 

type ScheduledClusterScanConfig struct {
	// Cron Expression for Schedule
	CronSchedule string `yaml:"cron_schedule" json:"cronSchedule,omitempty"`
	// Number of past scans to keep
	Retention int `yaml:"retention" json:"retention,omitempty"`
}

func (*ScheduledClusterScanConfig) DeepCopy 

func (in *ScheduledClusterScanConfig) DeepCopy() *ScheduledClusterScanConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScheduledClusterScanConfig.

func (*ScheduledClusterScanConfig) DeepCopyInto 

func (in *ScheduledClusterScanConfig) DeepCopyInto(out *ScheduledClusterScanConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ScheduledClusterScanStatus 

type ScheduledClusterScanStatus struct {
	Enabled          bool   `yaml:"enabled" json:"enabled,omitempty"`
	LastRunTimestamp string `yaml:"last_run_timestamp" json:"lastRunTimestamp"`
}

func (*ScheduledClusterScanStatus) DeepCopy 

func (in *ScheduledClusterScanStatus) DeepCopy() *ScheduledClusterScanStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScheduledClusterScanStatus.

func (*ScheduledClusterScanStatus) DeepCopyInto 

func (in *ScheduledClusterScanStatus) DeepCopyInto(out *ScheduledClusterScanStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SchedulerService 

type SchedulerService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
}

func (*SchedulerService) DeepCopy 

func (in *SchedulerService) DeepCopy() *SchedulerService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SchedulerService.

func (*SchedulerService) DeepCopyInto 

func (in *SchedulerService) DeepCopyInto(out *SchedulerService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SearchPrincipalsInput 

type SearchPrincipalsInput struct {
	Name          string `json:"name" norman:"type=string,required,notnullable"`
	PrincipalType string `json:"principalType,omitempty" norman:"type=enum,options=user|group"`
}

func (*SearchPrincipalsInput) DeepCopy 

func (in *SearchPrincipalsInput) DeepCopy() *SearchPrincipalsInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SearchPrincipalsInput.

func (*SearchPrincipalsInput) DeepCopyInto 

func (in *SearchPrincipalsInput) DeepCopyInto(out *SearchPrincipalsInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SecretsEncryptionConfig 

type SecretsEncryptionConfig struct {
	// Enable/disable secrets encryption provider config
	Enabled bool `yaml:"enabled" json:"enabled,omitempty"`
	// Custom Encryption Provider configuration object
	CustomConfig *apiserverconfig.EncryptionConfiguration `yaml:"custom_config" json:"customConfig,omitempty" norman:"type=map[json]"`
}

func (*SecretsEncryptionConfig) DeepCopy 

func (in *SecretsEncryptionConfig) DeepCopy() *SecretsEncryptionConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretsEncryptionConfig.

func (*SecretsEncryptionConfig) DeepCopyInto 

func (in *SecretsEncryptionConfig) DeepCopyInto(out *SecretsEncryptionConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ServiceOverride 

type ServiceOverride struct {
	Service       string `json:"service" yaml:"service" ini:"Service,omitempty"`
	Region        string `json:"region" yaml:"region" ini:"Region,omitempty"`
	URL           string `json:"url" yaml:"url" ini:"URL,omitempty"`
	SigningRegion string `json:"signing-region" yaml:"signing-region" ini:"SigningRegion,omitempty"`
	SigningMethod string `json:"signing-method" yaml:"signing-method" ini:"SigningMethod,omitempty"`
	SigningName   string `json:"signing-name" yaml:"signing-name" ini:"SigningName,omitempty"`
}

func (*ServiceOverride) DeepCopy 

func (in *ServiceOverride) DeepCopy() *ServiceOverride

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceOverride.

func (*ServiceOverride) DeepCopyInto 

func (in *ServiceOverride) DeepCopyInto(out *ServiceOverride)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SetPasswordInput 

type SetPasswordInput struct {
	NewPassword string `json:"newPassword" norman:"type=string,required"`
}

func (*SetPasswordInput) DeepCopy 

func (in *SetPasswordInput) DeepCopy() *SetPasswordInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SetPasswordInput.

func (*SetPasswordInput) DeepCopyInto 

func (in *SetPasswordInput) DeepCopyInto(out *SetPasswordInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SetPodSecurityPolicyTemplateInput 

type SetPodSecurityPolicyTemplateInput struct {
	PodSecurityPolicyTemplateName string `json:"podSecurityPolicyTemplateId" norman:"required,type=reference[podSecurityPolicyTemplate]"`
}

func (*SetPodSecurityPolicyTemplateInput) DeepCopy 

func (in *SetPodSecurityPolicyTemplateInput) DeepCopy() *SetPodSecurityPolicyTemplateInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SetPodSecurityPolicyTemplateInput.

func (*SetPodSecurityPolicyTemplateInput) DeepCopyInto 

func (in *SetPodSecurityPolicyTemplateInput) DeepCopyInto(out *SetPodSecurityPolicyTemplateInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Setting 

type Setting struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Value      string `json:"value" norman:"required"`
	Default    string `json:"default" norman:"nocreate,noupdate"`
	Customized bool   `json:"customized" norman:"nocreate,noupdate"`
	Source     string `json:"source" norman:"nocreate,noupdate,options=db|default|env"`
}

func NewSetting 

func NewSetting(namespace, name string, obj Setting) *Setting

func (*Setting) DeepCopy 

func (in *Setting) DeepCopy() *Setting

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Setting.

func (*Setting) DeepCopyInto 

func (in *Setting) DeepCopyInto(out *Setting)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Setting) DeepCopyObject 

func (in *Setting) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type SettingChangeHandlerFunc 

type SettingChangeHandlerFunc func(obj *Setting) (runtime.Object, error)

type SettingController 

type SettingController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() SettingLister
	AddHandler(ctx context.Context, name string, handler SettingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync SettingHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SettingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler SettingHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type SettingHandlerFunc 

type SettingHandlerFunc func(key string, obj *Setting) (runtime.Object, error)

func NewSettingLifecycleAdapter 

func NewSettingLifecycleAdapter(name string, clusterScoped bool, client SettingInterface, l SettingLifecycle) SettingHandlerFunc

type SettingInterface 

type SettingInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Setting) (*Setting, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Setting, error)
	Get(name string, opts metav1.GetOptions) (*Setting, error)
	Update(*Setting) (*Setting, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*SettingList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*SettingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() SettingController
	AddHandler(ctx context.Context, name string, sync SettingHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync SettingHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle SettingLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle SettingLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SettingHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync SettingHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SettingLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle SettingLifecycle)
}

type SettingLifecycle 

type SettingLifecycle interface {
	Create(obj *Setting) (runtime.Object, error)
	Remove(obj *Setting) (runtime.Object, error)
	Updated(obj *Setting) (runtime.Object, error)
}

type SettingList 

type SettingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Setting `json:"items"`
}

func (*SettingList) DeepCopy 

func (in *SettingList) DeepCopy() *SettingList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SettingList.

func (*SettingList) DeepCopyInto 

func (in *SettingList) DeepCopyInto(out *SettingList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*SettingList) DeepCopyObject 

func (in *SettingList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type SettingLister 

type SettingLister interface {
	List(namespace string, selector labels.Selector) (ret []*Setting, err error)
	Get(namespace, name string) (*Setting, error)
}

type SettingsGetter 

type SettingsGetter interface {
	Settings(namespace string) SettingInterface
}

type ShibbolethConfig 

type ShibbolethConfig struct {
	SamlConfig     `json:",inline" mapstructure:",squash"`
	OpenLdapConfig LdapFields `json:"openLdapConfig" mapstructure:",squash"`
}

func (*ShibbolethConfig) DeepCopy 

func (in *ShibbolethConfig) DeepCopy() *ShibbolethConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ShibbolethConfig.

func (*ShibbolethConfig) DeepCopyInto 

func (in *ShibbolethConfig) DeepCopyInto(out *ShibbolethConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ShibbolethConfig) DeepCopyObject 

func (in *ShibbolethConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type SlackConfig 

type SlackConfig struct {
	DefaultRecipient string `json:"defaultRecipient,omitempty"`
	URL              string `json:"url,omitempty" norman:"required"`
	*HTTPClientConfig
}

func (*SlackConfig) DeepCopy 

func (in *SlackConfig) DeepCopy() *SlackConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SlackConfig.

func (*SlackConfig) DeepCopyInto 

func (in *SlackConfig) DeepCopyInto(out *SlackConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SplunkConfig 

type SplunkConfig struct {
	Endpoint      string `json:"endpoint,omitempty" norman:"required"`
	Source        string `json:"source,omitempty"`
	Token         string `json:"token,omitempty" norman:"required,type=password"`
	Certificate   string `json:"certificate,omitempty"`
	ClientCert    string `json:"clientCert,omitempty"`
	ClientKey     string `json:"clientKey,omitempty"`
	ClientKeyPass string `json:"clientKeyPass,omitempty"`
	SSLVerify     bool   `json:"sslVerify,omitempty"`
	Index         string `json:"index,omitempty"`
}

func (*SplunkConfig) DeepCopy 

func (in *SplunkConfig) DeepCopy() *SplunkConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SplunkConfig.

func (*SplunkConfig) DeepCopyInto 

func (in *SplunkConfig) DeepCopyInto(out *SplunkConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SubQuestion 

type SubQuestion struct {
	Variable     string   `json:"variable,omitempty" yaml:"variable,omitempty"`
	Label        string   `json:"label,omitempty" yaml:"label,omitempty"`
	Description  string   `json:"description,omitempty" yaml:"description,omitempty"`
	Type         string   `json:"type,omitempty" yaml:"type,omitempty"`
	Required     bool     `json:"required,omitempty" yaml:"required,omitempty"`
	Default      string   `json:"default,omitempty" yaml:"default,omitempty"`
	Group        string   `json:"group,omitempty" yaml:"group,omitempty"`
	MinLength    int      `json:"minLength,omitempty" yaml:"min_length,omitempty"`
	MaxLength    int      `json:"maxLength,omitempty" yaml:"max_length,omitempty"`
	Min          int      `json:"min,omitempty" yaml:"min,omitempty"`
	Max          int      `json:"max,omitempty" yaml:"max,omitempty"`
	Options      []string `json:"options,omitempty" yaml:"options,omitempty"`
	ValidChars   string   `json:"validChars,omitempty" yaml:"valid_chars,omitempty"`
	InvalidChars string   `json:"invalidChars,omitempty" yaml:"invalid_chars,omitempty"`
	ShowIf       string   `json:"showIf,omitempty" yaml:"show_if,omitempty"`
	Satisfies    string   `json:"satisfies,omitempty" yaml:"satisfies,omitempty"`
}

func (*SubQuestion) DeepCopy 

func (in *SubQuestion) DeepCopy() *SubQuestion

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubQuestion.

func (*SubQuestion) DeepCopyInto 

func (in *SubQuestion) DeepCopyInto(out *SubQuestion)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SyslogConfig 

type SyslogConfig struct {
	Endpoint    string `json:"endpoint,omitempty" norman:"required"`
	Severity    string `json:"severity,omitempty" norman:"default=notice,type=enum,options=emerg|alert|crit|err|warning|notice|info|debug"`
	Program     string `json:"program,omitempty"`
	Protocol    string `json:"protocol,omitempty" norman:"default=udp,type=enum,options=udp|tcp"`
	Token       string `json:"token,omitempty" norman:"type=password"`
	EnableTLS   bool   `json:"enableTls,omitempty" norman:"default=false"`
	Certificate string `json:"certificate,omitempty"`
	ClientCert  string `json:"clientCert,omitempty"`
	ClientKey   string `json:"clientKey,omitempty"`
	SSLVerify   bool   `json:"sslVerify,omitempty"`
}

func (*SyslogConfig) DeepCopy 

func (in *SyslogConfig) DeepCopy() *SyslogConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SyslogConfig.

func (*SyslogConfig) DeepCopyInto 

func (in *SyslogConfig) DeepCopyInto(out *SyslogConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SystemServiceRule 

type SystemServiceRule struct {
	Condition string `json:"condition,omitempty" norman:"required,options=etcd|controller-manager|scheduler,default=scheduler"`
}

func (*SystemServiceRule) DeepCopy 

func (in *SystemServiceRule) DeepCopy() *SystemServiceRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SystemServiceRule.

func (*SystemServiceRule) DeepCopyInto 

func (in *SystemServiceRule) DeepCopyInto(out *SystemServiceRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Target 

type Target struct {
	ProjectName string `json:"projectName,omitempty" norman:"type=reference[project],required"`
	AppName     string `json:"appName,omitempty" norman:"type=reference[v3/projects/schemas/app]"`
	State       string `json:"state,omitempty"`
	Healthstate string `json:"healthState,omitempty"`
}

func (*Target) DeepCopy 

func (in *Target) DeepCopy() *Target

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Target.

func (*Target) DeepCopyInto 

func (in *Target) DeepCopyInto(out *Target)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Target) ObjClusterName 

func (t *Target) ObjClusterName() string

type TargetEvent 

type TargetEvent struct {
	EventType    string `json:"eventType,omitempty" norman:"required,options=Normal|Warning,default=Warning"`
	ResourceKind string `json:"resourceKind,omitempty" norman:"required,options=Pod|Node|Deployment|StatefulSet|DaemonSet"`
}

func (*TargetEvent) DeepCopy 

func (in *TargetEvent) DeepCopy() *TargetEvent

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TargetEvent.

func (*TargetEvent) DeepCopyInto 

func (in *TargetEvent) DeepCopyInto(out *TargetEvent)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TargetNode 

type TargetNode struct {
	NodeName     string            `json:"nodeName,omitempty" norman:"type=reference[node]"`
	Selector     map[string]string `json:"selector,omitempty"`
	Condition    string            `json:"condition,omitempty" norman:"required,options=notready|mem|cpu,default=notready"`
	MemThreshold int               `json:"memThreshold,omitempty" norman:"min=1,max=100,default=70"`
	CPUThreshold int               `json:"cpuThreshold,omitempty" norman:"min=1,default=70"`
}

func (*TargetNode) DeepCopy 

func (in *TargetNode) DeepCopy() *TargetNode

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TargetNode.

func (*TargetNode) DeepCopyInto 

func (in *TargetNode) DeepCopyInto(out *TargetNode)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TargetPod 

type TargetPod struct {
	PodName                string `json:"podName,omitempty" norman:"required,type=reference[/v3/projects/schemas/pod]"`
	Condition              string `json:"condition,omitempty" norman:"required,options=notrunning|notscheduled|restarts,default=notrunning"`
	RestartTimes           int    `json:"restartTimes,omitempty" norman:"min=1,default=3"`
	RestartIntervalSeconds int    `json:"restartIntervalSeconds,omitempty"  norman:"min=1,default=300"`
}

func (*TargetPod) DeepCopy 

func (in *TargetPod) DeepCopy() *TargetPod

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TargetPod.

func (*TargetPod) DeepCopyInto 

func (in *TargetPod) DeepCopyInto(out *TargetPod)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TargetSystemService 

type TargetSystemService struct {
	Condition string `json:"condition,omitempty" norman:"required,options=etcd|controller-manager|scheduler,default=scheduler"`
}

func (*TargetSystemService) DeepCopy 

func (in *TargetSystemService) DeepCopy() *TargetSystemService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TargetSystemService.

func (*TargetSystemService) DeepCopyInto 

func (in *TargetSystemService) DeepCopyInto(out *TargetSystemService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TargetWorkload 

type TargetWorkload struct {
	WorkloadID          string            `json:"workloadId,omitempty"`
	Selector            map[string]string `json:"selector,omitempty"`
	AvailablePercentage int               `json:"availablePercentage,omitempty" norman:"required,min=1,max=100,default=70"`
}

func (*TargetWorkload) DeepCopy 

func (in *TargetWorkload) DeepCopy() *TargetWorkload

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TargetWorkload.

func (*TargetWorkload) DeepCopyInto 

func (in *TargetWorkload) DeepCopyInto(out *TargetWorkload)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Template 

type Template struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec   TemplateSpec   `json:"spec"`
	Status TemplateStatus `json:"status"`
}

func NewTemplate 

func NewTemplate(namespace, name string, obj Template) *Template

func (*Template) DeepCopy 

func (in *Template) DeepCopy() *Template

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Template.

func (*Template) DeepCopyInto 

func (in *Template) DeepCopyInto(out *Template)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Template) DeepCopyObject 

func (in *Template) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type TemplateChangeHandlerFunc 

type TemplateChangeHandlerFunc func(obj *Template) (runtime.Object, error)

type TemplateContent deprecated 

type TemplateContent struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Data string `json:"data,omitempty"`
}

TemplateContent is deprecated

Deprecated: Do not use

func NewTemplateContent 

func NewTemplateContent(namespace, name string, obj TemplateContent) *TemplateContent

func (*TemplateContent) DeepCopy 

func (in *TemplateContent) DeepCopy() *TemplateContent

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateContent.

func (*TemplateContent) DeepCopyInto 

func (in *TemplateContent) DeepCopyInto(out *TemplateContent)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*TemplateContent) DeepCopyObject 

func (in *TemplateContent) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type TemplateContentChangeHandlerFunc 

type TemplateContentChangeHandlerFunc func(obj *TemplateContent) (runtime.Object, error)

type TemplateContentController 

type TemplateContentController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() TemplateContentLister
	AddHandler(ctx context.Context, name string, handler TemplateContentHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TemplateContentHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TemplateContentHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler TemplateContentHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type TemplateContentHandlerFunc 

type TemplateContentHandlerFunc func(key string, obj *TemplateContent) (runtime.Object, error)

func NewTemplateContentLifecycleAdapter 

func NewTemplateContentLifecycleAdapter(name string, clusterScoped bool, client TemplateContentInterface, l TemplateContentLifecycle) TemplateContentHandlerFunc

type TemplateContentInterface 

type TemplateContentInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*TemplateContent) (*TemplateContent, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*TemplateContent, error)
	Get(name string, opts metav1.GetOptions) (*TemplateContent, error)
	Update(*TemplateContent) (*TemplateContent, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*TemplateContentList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*TemplateContentList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() TemplateContentController
	AddHandler(ctx context.Context, name string, sync TemplateContentHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TemplateContentHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle TemplateContentLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle TemplateContentLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateContentHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync TemplateContentHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateContentLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle TemplateContentLifecycle)
}

type TemplateContentLifecycle 

type TemplateContentLifecycle interface {
	Create(obj *TemplateContent) (runtime.Object, error)
	Remove(obj *TemplateContent) (runtime.Object, error)
	Updated(obj *TemplateContent) (runtime.Object, error)
}

type TemplateContentList 

type TemplateContentList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []TemplateContent `json:"items"`
}

func (*TemplateContentList) DeepCopy 

func (in *TemplateContentList) DeepCopy() *TemplateContentList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateContentList.

func (*TemplateContentList) DeepCopyInto 

func (in *TemplateContentList) DeepCopyInto(out *TemplateContentList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*TemplateContentList) DeepCopyObject 

func (in *TemplateContentList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type TemplateContentLister 

type TemplateContentLister interface {
	List(namespace string, selector labels.Selector) (ret []*TemplateContent, err error)
	Get(namespace, name string) (*TemplateContent, error)
}

type TemplateContentsGetter 

type TemplateContentsGetter interface {
	TemplateContents(namespace string) TemplateContentInterface
}

type TemplateController 

type TemplateController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() TemplateLister
	AddHandler(ctx context.Context, name string, handler TemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TemplateHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler TemplateHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type TemplateHandlerFunc 

type TemplateHandlerFunc func(key string, obj *Template) (runtime.Object, error)

func NewTemplateLifecycleAdapter 

func NewTemplateLifecycleAdapter(name string, clusterScoped bool, client TemplateInterface, l TemplateLifecycle) TemplateHandlerFunc

type TemplateInterface 

type TemplateInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Template) (*Template, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Template, error)
	Get(name string, opts metav1.GetOptions) (*Template, error)
	Update(*Template) (*Template, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*TemplateList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*TemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() TemplateController
	AddHandler(ctx context.Context, name string, sync TemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TemplateHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle TemplateLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle TemplateLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync TemplateHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle TemplateLifecycle)
}

type TemplateLifecycle 

type TemplateLifecycle interface {
	Create(obj *Template) (runtime.Object, error)
	Remove(obj *Template) (runtime.Object, error)
	Updated(obj *Template) (runtime.Object, error)
}

type TemplateList 

type TemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Template `json:"items"`
}

func (*TemplateList) DeepCopy 

func (in *TemplateList) DeepCopy() *TemplateList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateList.

func (*TemplateList) DeepCopyInto 

func (in *TemplateList) DeepCopyInto(out *TemplateList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*TemplateList) DeepCopyObject 

func (in *TemplateList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type TemplateLister 

type TemplateLister interface {
	List(namespace string, selector labels.Selector) (ret []*Template, err error)
	Get(namespace, name string) (*Template, error)
}

type TemplateSpec 

type TemplateSpec struct {
	DisplayName              string `json:"displayName"`
	CatalogID                string `json:"catalogId,omitempty" norman:"type=reference[catalog]"`
	ProjectCatalogID         string `json:"projectCatalogId,omitempty" norman:"type=reference[projectCatalog]"`
	ClusterCatalogID         string `json:"clusterCatalogId,omitempty" norman:"type=reference[clusterCatalog]"`
	DefaultTemplateVersionID string `json:"defaultTemplateVersionId,omitempty" norman:"type=reference[templateVersion]"`
	ProjectID                string `json:"projectId,omitempty" norman:"required,type=reference[project]"`
	ClusterID                string `json:"clusterId,omitempty" norman:"required,type=reference[cluster]"`

	Description    string `json:"description,omitempty"`
	DefaultVersion string `json:"defaultVersion,omitempty" yaml:"default_version,omitempty"`
	Path           string `json:"path,omitempty"`
	Maintainer     string `json:"maintainer,omitempty"`
	ProjectURL     string `json:"projectURL,omitempty" yaml:"project_url,omitempty"`
	UpgradeFrom    string `json:"upgradeFrom,omitempty"`
	FolderName     string `json:"folderName,omitempty"`
	Icon           string `json:"icon,omitempty"`
	IconFilename   string `json:"iconFilename,omitempty"`

	// Deprecated: Do not use
	Readme string `json:"readme,omitempty" norman:"nocreate,noupdate"`

	Categories []string              `json:"categories,omitempty"`
	Versions   []TemplateVersionSpec `json:"versions,omitempty"`

	Category string `json:"category,omitempty"`
}

func (*TemplateSpec) DeepCopy 

func (in *TemplateSpec) DeepCopy() *TemplateSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateSpec.

func (*TemplateSpec) DeepCopyInto 

func (in *TemplateSpec) DeepCopyInto(out *TemplateSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TemplateStatus 

type TemplateStatus struct {
	HelmVersion string `json:"helmVersion,omitempty" norman:"noupdate,nocreate"`
}

func (*TemplateStatus) DeepCopy 

func (in *TemplateStatus) DeepCopy() *TemplateStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateStatus.

func (*TemplateStatus) DeepCopyInto 

func (in *TemplateStatus) DeepCopyInto(out *TemplateStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TemplateVersion 

type TemplateVersion struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object’s metadata. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Specification of the desired behavior of the the cluster. More info:
	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec   TemplateVersionSpec   `json:"spec"`
	Status TemplateVersionStatus `json:"status"`
}

func NewTemplateVersion 

func NewTemplateVersion(namespace, name string, obj TemplateVersion) *TemplateVersion

func (*TemplateVersion) DeepCopy 

func (in *TemplateVersion) DeepCopy() *TemplateVersion

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateVersion.

func (*TemplateVersion) DeepCopyInto 

func (in *TemplateVersion) DeepCopyInto(out *TemplateVersion)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*TemplateVersion) DeepCopyObject 

func (in *TemplateVersion) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type TemplateVersionChangeHandlerFunc 

type TemplateVersionChangeHandlerFunc func(obj *TemplateVersion) (runtime.Object, error)

type TemplateVersionController 

type TemplateVersionController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() TemplateVersionLister
	AddHandler(ctx context.Context, name string, handler TemplateVersionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TemplateVersionHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TemplateVersionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler TemplateVersionHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type TemplateVersionHandlerFunc 

type TemplateVersionHandlerFunc func(key string, obj *TemplateVersion) (runtime.Object, error)

func NewTemplateVersionLifecycleAdapter 

func NewTemplateVersionLifecycleAdapter(name string, clusterScoped bool, client TemplateVersionInterface, l TemplateVersionLifecycle) TemplateVersionHandlerFunc

type TemplateVersionInterface 

type TemplateVersionInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*TemplateVersion) (*TemplateVersion, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*TemplateVersion, error)
	Get(name string, opts metav1.GetOptions) (*TemplateVersion, error)
	Update(*TemplateVersion) (*TemplateVersion, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*TemplateVersionList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*TemplateVersionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() TemplateVersionController
	AddHandler(ctx context.Context, name string, sync TemplateVersionHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TemplateVersionHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle TemplateVersionLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle TemplateVersionLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateVersionHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync TemplateVersionHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateVersionLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle TemplateVersionLifecycle)
}

type TemplateVersionLifecycle 

type TemplateVersionLifecycle interface {
	Create(obj *TemplateVersion) (runtime.Object, error)
	Remove(obj *TemplateVersion) (runtime.Object, error)
	Updated(obj *TemplateVersion) (runtime.Object, error)
}

type TemplateVersionList 

type TemplateVersionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []TemplateVersion `json:"items"`
}

func (*TemplateVersionList) DeepCopy 

func (in *TemplateVersionList) DeepCopy() *TemplateVersionList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateVersionList.

func (*TemplateVersionList) DeepCopyInto 

func (in *TemplateVersionList) DeepCopyInto(out *TemplateVersionList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*TemplateVersionList) DeepCopyObject 

func (in *TemplateVersionList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type TemplateVersionLister 

type TemplateVersionLister interface {
	List(namespace string, selector labels.Selector) (ret []*TemplateVersion, err error)
	Get(namespace, name string) (*TemplateVersion, error)
}

type TemplateVersionSpec 

type TemplateVersionSpec struct {
	ExternalID          string            `json:"externalId,omitempty"`
	Version             string            `json:"version,omitempty"`
	RancherVersion      string            `json:"rancherVersion,omitempty"`
	RequiredNamespace   string            `json:"requiredNamespace,omitempty"`
	KubeVersion         string            `json:"kubeVersion,omitempty"`
	UpgradeVersionLinks map[string]string `json:"upgradeVersionLinks,omitempty"`
	Digest              string            `json:"digest,omitempty"`
	RancherMinVersion   string            `json:"rancherMinVersion,omitempty"`
	RancherMaxVersion   string            `json:"rancherMaxVersion,omitempty"`

	// Deprecated: Do not use
	Files map[string]string `json:"files,omitempty" norman:"nocreate,noupdate"`
	// Deprecated: Do not use
	Questions []Question `json:"questions,omitempty" norman:"nocreate,noupdate"`
	// Deprecated: Do not use
	Readme string `json:"readme,omitempty" norman:"nocreate,noupdate"`
	// Deprecated: Do not use
	AppReadme string `json:"appReadme,omitempty" norman:"nocreate,noupdate"`

	// for local cache rebuilt
	VersionName string   `json:"versionName,omitempty"`
	VersionDir  string   `json:"versionDir,omitempty"`
	VersionURLs []string `json:"versionUrls,omitempty"`
}

func (*TemplateVersionSpec) DeepCopy 

func (in *TemplateVersionSpec) DeepCopy() *TemplateVersionSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateVersionSpec.

func (*TemplateVersionSpec) DeepCopyInto 

func (in *TemplateVersionSpec) DeepCopyInto(out *TemplateVersionSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TemplateVersionStatus 

type TemplateVersionStatus struct {
	HelmVersion string `json:"helmVersion,omitempty" norman:"noupdate,nocreate"`
}

func (*TemplateVersionStatus) DeepCopy 

func (in *TemplateVersionStatus) DeepCopy() *TemplateVersionStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TemplateVersionStatus.

func (*TemplateVersionStatus) DeepCopyInto 

func (in *TemplateVersionStatus) DeepCopyInto(out *TemplateVersionStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TemplateVersionsGetter 

type TemplateVersionsGetter interface {
	TemplateVersions(namespace string) TemplateVersionInterface
}

type TemplatesGetter 

type TemplatesGetter interface {
	Templates(namespace string) TemplateInterface
}

type TimeSeries 

type TimeSeries struct {
	Name   string      `json:"name"`
	Points [][]float64 `json:"points" norman:"type=array[array[float]]"`
}

func (*TimeSeries) DeepCopy 

func (in *TimeSeries) DeepCopy() *TimeSeries

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TimeSeries.

func (*TimeSeries) DeepCopyInto 

func (in *TimeSeries) DeepCopyInto(out *TimeSeries)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TimingField 

type TimingField struct {
	GroupWaitSeconds      int `json:"groupWaitSeconds,omitempty" norman:"required,default=30,min=1"`
	GroupIntervalSeconds  int `json:"groupIntervalSeconds,omitempty" norman:"required,default=180,min=1"`
	RepeatIntervalSeconds int `json:"repeatIntervalSeconds,omitempty"  norman:"required,default=3600,min=1"`
}

func (*TimingField) DeepCopy 

func (in *TimingField) DeepCopy() *TimingField

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TimingField.

func (*TimingField) DeepCopyInto 

func (in *TimingField) DeepCopyInto(out *TimingField)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Token 

type Token struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Token           string            `json:"token" norman:"writeOnly,noupdate"`
	UserPrincipal   Principal         `json:"userPrincipal" norman:"type=reference[principal]"`
	GroupPrincipals []Principal       `json:"groupPrincipals" norman:"type=array[reference[principal]]"`
	ProviderInfo    map[string]string `json:"providerInfo,omitempty"`
	UserID          string            `json:"userId" norman:"type=reference[user]"`
	AuthProvider    string            `json:"authProvider"`
	TTLMillis       int64             `json:"ttl"`
	LastUpdateTime  string            `json:"lastUpdateTime"`
	IsDerived       bool              `json:"isDerived"`
	Description     string            `json:"description"`
	Expired         bool              `json:"expired"`
	ExpiresAt       string            `json:"expiresAt"`
	Current         bool              `json:"current"`
	ClusterName     string            `json:"clusterName,omitempty" norman:"noupdate,type=reference[cluster]"`
	Enabled         *bool             `json:"enabled,omitempty" norman:"default=true"`
}

func NewToken 

func NewToken(namespace, name string, obj Token) *Token

func (*Token) DeepCopy 

func (in *Token) DeepCopy() *Token

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Token.

func (*Token) DeepCopyInto 

func (in *Token) DeepCopyInto(out *Token)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Token) DeepCopyObject 

func (in *Token) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*Token) ObjClusterName 

func (t *Token) ObjClusterName() string

type TokenChangeHandlerFunc 

type TokenChangeHandlerFunc func(obj *Token) (runtime.Object, error)

type TokenController 

type TokenController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() TokenLister
	AddHandler(ctx context.Context, name string, handler TokenHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TokenHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TokenHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler TokenHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type TokenHandlerFunc 

type TokenHandlerFunc func(key string, obj *Token) (runtime.Object, error)

func NewTokenLifecycleAdapter 

func NewTokenLifecycleAdapter(name string, clusterScoped bool, client TokenInterface, l TokenLifecycle) TokenHandlerFunc

type TokenInterface 

type TokenInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Token) (*Token, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Token, error)
	Get(name string, opts metav1.GetOptions) (*Token, error)
	Update(*Token) (*Token, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*TokenList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*TokenList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() TokenController
	AddHandler(ctx context.Context, name string, sync TokenHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync TokenHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle TokenLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle TokenLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TokenHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync TokenHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TokenLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle TokenLifecycle)
}

type TokenLifecycle 

type TokenLifecycle interface {
	Create(obj *Token) (runtime.Object, error)
	Remove(obj *Token) (runtime.Object, error)
	Updated(obj *Token) (runtime.Object, error)
}

type TokenList 

type TokenList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Token `json:"items"`
}

func (*TokenList) DeepCopy 

func (in *TokenList) DeepCopy() *TokenList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TokenList.

func (*TokenList) DeepCopyInto 

func (in *TokenList) DeepCopyInto(out *TokenList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*TokenList) DeepCopyObject 

func (in *TokenList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type TokenLister 

type TokenLister interface {
	List(namespace string, selector labels.Selector) (ret []*Token, err error)
	Get(namespace, name string) (*Token, error)
}

type TokensGetter 

type TokensGetter interface {
	Tokens(namespace string) TokenInterface
}

type UpdateGlobalDNSTargetsInput 

type UpdateGlobalDNSTargetsInput struct {
	ProjectNames []string `json:"projectNames" norman:"type=array[reference[project]]"`
}

func (*UpdateGlobalDNSTargetsInput) DeepCopy 

func (in *UpdateGlobalDNSTargetsInput) DeepCopy() *UpdateGlobalDNSTargetsInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UpdateGlobalDNSTargetsInput.

func (*UpdateGlobalDNSTargetsInput) DeepCopyInto 

func (in *UpdateGlobalDNSTargetsInput) DeepCopyInto(out *UpdateGlobalDNSTargetsInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type UpdateMultiClusterAppTargetsInput 

type UpdateMultiClusterAppTargetsInput struct {
	Projects []string `json:"projects" norman:"type=array[reference[project]],required"`
	Answers  []Answer `json:"answers"`
}

func (*UpdateMultiClusterAppTargetsInput) DeepCopy 

func (in *UpdateMultiClusterAppTargetsInput) DeepCopy() *UpdateMultiClusterAppTargetsInput

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UpdateMultiClusterAppTargetsInput.

func (*UpdateMultiClusterAppTargetsInput) DeepCopyInto 

func (in *UpdateMultiClusterAppTargetsInput) DeepCopyInto(out *UpdateMultiClusterAppTargetsInput)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type UpgradeStrategy 

type UpgradeStrategy struct {
	RollingUpdate *RollingUpdate `json:"rollingUpdate,omitempty"`
}

func (*UpgradeStrategy) DeepCopy 

func (in *UpgradeStrategy) DeepCopy() *UpgradeStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UpgradeStrategy.

func (*UpgradeStrategy) DeepCopyInto 

func (in *UpgradeStrategy) DeepCopyInto(out *UpgradeStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type User 

type User struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	DisplayName        string     `json:"displayName,omitempty"`
	Description        string     `json:"description"`
	Username           string     `json:"username,omitempty"`
	Password           string     `json:"password,omitempty" norman:"writeOnly,noupdate"`
	MustChangePassword bool       `json:"mustChangePassword,omitempty"`
	PrincipalIDs       []string   `json:"principalIds,omitempty" norman:"type=array[reference[principal]]"`
	Me                 bool       `json:"me,omitempty" norman:"nocreate,noupdate"`
	Enabled            *bool      `json:"enabled,omitempty" norman:"default=true"`
	Spec               UserSpec   `json:"spec,omitempty"`
	Status             UserStatus `json:"status"`
}

func NewUser 

func NewUser(namespace, name string, obj User) *User

func (*User) DeepCopy 

func (in *User) DeepCopy() *User

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new User.

func (*User) DeepCopyInto 

func (in *User) DeepCopyInto(out *User)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*User) DeepCopyObject 

func (in *User) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type UserAttribute 

type UserAttribute struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	UserName        string
	GroupPrincipals map[string]Principals // the value is a []Principal, but code generator cannot handle slice as a value
	LastRefresh     string
	NeedsRefresh    bool
}

UserAttribute will have a CRD (and controller) generated for it, but will not be exposed in the API.

func NewUserAttribute 

func NewUserAttribute(namespace, name string, obj UserAttribute) *UserAttribute

func (*UserAttribute) DeepCopy 

func (in *UserAttribute) DeepCopy() *UserAttribute

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserAttribute.

func (*UserAttribute) DeepCopyInto 

func (in *UserAttribute) DeepCopyInto(out *UserAttribute)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*UserAttribute) DeepCopyObject 

func (in *UserAttribute) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type UserAttributeChangeHandlerFunc 

type UserAttributeChangeHandlerFunc func(obj *UserAttribute) (runtime.Object, error)

type UserAttributeController 

type UserAttributeController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() UserAttributeLister
	AddHandler(ctx context.Context, name string, handler UserAttributeHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync UserAttributeHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler UserAttributeHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler UserAttributeHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type UserAttributeHandlerFunc 

type UserAttributeHandlerFunc func(key string, obj *UserAttribute) (runtime.Object, error)

func NewUserAttributeLifecycleAdapter 

func NewUserAttributeLifecycleAdapter(name string, clusterScoped bool, client UserAttributeInterface, l UserAttributeLifecycle) UserAttributeHandlerFunc

type UserAttributeInterface 

type UserAttributeInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*UserAttribute) (*UserAttribute, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*UserAttribute, error)
	Get(name string, opts metav1.GetOptions) (*UserAttribute, error)
	Update(*UserAttribute) (*UserAttribute, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*UserAttributeList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*UserAttributeList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() UserAttributeController
	AddHandler(ctx context.Context, name string, sync UserAttributeHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync UserAttributeHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle UserAttributeLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle UserAttributeLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync UserAttributeHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync UserAttributeHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle UserAttributeLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle UserAttributeLifecycle)
}

type UserAttributeLifecycle 

type UserAttributeLifecycle interface {
	Create(obj *UserAttribute) (runtime.Object, error)
	Remove(obj *UserAttribute) (runtime.Object, error)
	Updated(obj *UserAttribute) (runtime.Object, error)
}

type UserAttributeList 

type UserAttributeList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []UserAttribute `json:"items"`
}

func (*UserAttributeList) DeepCopy 

func (in *UserAttributeList) DeepCopy() *UserAttributeList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserAttributeList.

func (*UserAttributeList) DeepCopyInto 

func (in *UserAttributeList) DeepCopyInto(out *UserAttributeList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*UserAttributeList) DeepCopyObject 

func (in *UserAttributeList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type UserAttributeLister 

type UserAttributeLister interface {
	List(namespace string, selector labels.Selector) (ret []*UserAttribute, err error)
	Get(namespace, name string) (*UserAttribute, error)
}

type UserAttributesGetter 

type UserAttributesGetter interface {
	UserAttributes(namespace string) UserAttributeInterface
}

type UserChangeHandlerFunc 

type UserChangeHandlerFunc func(obj *User) (runtime.Object, error)

type UserCondition 

type UserCondition struct {
	// Type of user condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

func (*UserCondition) DeepCopy 

func (in *UserCondition) DeepCopy() *UserCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserCondition.

func (*UserCondition) DeepCopyInto 

func (in *UserCondition) DeepCopyInto(out *UserCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type UserController 

type UserController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() UserLister
	AddHandler(ctx context.Context, name string, handler UserHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync UserHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler UserHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler UserHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type UserHandlerFunc 

type UserHandlerFunc func(key string, obj *User) (runtime.Object, error)

func NewUserLifecycleAdapter 

func NewUserLifecycleAdapter(name string, clusterScoped bool, client UserInterface, l UserLifecycle) UserHandlerFunc

type UserInterface 

type UserInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*User) (*User, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*User, error)
	Get(name string, opts metav1.GetOptions) (*User, error)
	Update(*User) (*User, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*UserList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*UserList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() UserController
	AddHandler(ctx context.Context, name string, sync UserHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync UserHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle UserLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle UserLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync UserHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync UserHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle UserLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle UserLifecycle)
}

type UserLifecycle 

type UserLifecycle interface {
	Create(obj *User) (runtime.Object, error)
	Remove(obj *User) (runtime.Object, error)
	Updated(obj *User) (runtime.Object, error)
}

type UserList 

type UserList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []User `json:"items"`
}

func (*UserList) DeepCopy 

func (in *UserList) DeepCopy() *UserList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserList.

func (*UserList) DeepCopyInto 

func (in *UserList) DeepCopyInto(out *UserList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*UserList) DeepCopyObject 

func (in *UserList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type UserLister 

type UserLister interface {
	List(namespace string, selector labels.Selector) (ret []*User, err error)
	Get(namespace, name string) (*User, error)
}

type UserSpec 

type UserSpec struct{}

func (*UserSpec) DeepCopy 

func (in *UserSpec) DeepCopy() *UserSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserSpec.

func (*UserSpec) DeepCopyInto 

func (in *UserSpec) DeepCopyInto(out *UserSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type UserStatus 

type UserStatus struct {
	Conditions []UserCondition `json:"conditions"`
}

func (*UserStatus) DeepCopy 

func (in *UserStatus) DeepCopy() *UserStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserStatus.

func (*UserStatus) DeepCopyInto 

func (in *UserStatus) DeepCopyInto(out *UserStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type UsersGetter 

type UsersGetter interface {
	Users(namespace string) UserInterface
}

type Values 

type Values struct {
	StringValue      string   `json:"stringValue"`
	IntValue         int      `json:"intValue"`
	BoolValue        bool     `json:"boolValue"`
	StringSliceValue []string `json:"stringSliceValue"`
}

func (*Values) DeepCopy 

func (in *Values) DeepCopy() *Values

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Values.

func (*Values) DeepCopyInto 

func (in *Values) DeepCopyInto(out *Values)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VersionCommits 

type VersionCommits struct {
	Value map[string]string `json:"Value,omitempty"`
}

func (*VersionCommits) DeepCopy 

func (in *VersionCommits) DeepCopy() *VersionCommits

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VersionCommits.

func (*VersionCommits) DeepCopyInto 

func (in *VersionCommits) DeepCopyInto(out *VersionCommits)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualCenterConfig 

type VirtualCenterConfig struct {
	User              string `json:"user,omitempty" yaml:"user,omitempty" ini:"user,omitempty"`
	Password          string `json:"password,omitempty" yaml:"password,omitempty" ini:"password,omitempty" norman:"type=password"`
	VCenterPort       string `json:"port,omitempty" yaml:"port,omitempty" ini:"port,omitempty"`
	Datacenters       string `json:"datacenters,omitempty" yaml:"datacenters,omitempty" ini:"datacenters,omitempty"`
	RoundTripperCount int    `json:"soap-roundtrip-count,omitempty" yaml:"soap-roundtrip-count,omitempty" ini:"soap-roundtrip-count,omitempty"`
}

func (*VirtualCenterConfig) DeepCopy 

func (in *VirtualCenterConfig) DeepCopy() *VirtualCenterConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualCenterConfig.

func (*VirtualCenterConfig) DeepCopyInto 

func (in *VirtualCenterConfig) DeepCopyInto(out *VirtualCenterConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VsphereCloudProvider 

type VsphereCloudProvider struct {
	Global        GlobalVsphereOpts              `json:"global,omitempty" yaml:"global,omitempty" ini:"Global,omitempty"`
	VirtualCenter map[string]VirtualCenterConfig `json:"virtualCenter,omitempty" yaml:"virtual_center,omitempty" ini:"VirtualCenter,omitempty"`
	Network       NetworkVshpereOpts             `json:"network,omitempty" yaml:"network,omitempty" ini:"Network,omitempty"`
	Disk          DiskVsphereOpts                `json:"disk,omitempty" yaml:"disk,omitempty" ini:"Disk,omitempty"`
	Workspace     WorkspaceVsphereOpts           `json:"workspace,omitempty" yaml:"workspace,omitempty" ini:"Workspace,omitempty"`
}

VsphereCloudProvider options

func (*VsphereCloudProvider) DeepCopy 

func (in *VsphereCloudProvider) DeepCopy() *VsphereCloudProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VsphereCloudProvider.

func (*VsphereCloudProvider) DeepCopyInto 

func (in *VsphereCloudProvider) DeepCopyInto(out *VsphereCloudProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WeaveNetworkProvider 

type WeaveNetworkProvider struct {
	Password string `yaml:"password,omitempty" json:"password,omitempty" norman:"type=password"`
}

func (*WeaveNetworkProvider) DeepCopy 

func (in *WeaveNetworkProvider) DeepCopy() *WeaveNetworkProvider

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WeaveNetworkProvider.

func (*WeaveNetworkProvider) DeepCopyInto 

func (in *WeaveNetworkProvider) DeepCopyInto(out *WeaveNetworkProvider)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WebhookConfig 

type WebhookConfig struct {
	URL string `json:"url,omitempty" norman:"required"`
	*HTTPClientConfig
}

func (*WebhookConfig) DeepCopy 

func (in *WebhookConfig) DeepCopy() *WebhookConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WebhookConfig.

func (*WebhookConfig) DeepCopyInto 

func (in *WebhookConfig) DeepCopyInto(out *WebhookConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WechatConfig 

type WechatConfig struct {
	DefaultRecipient string `json:"defaultRecipient,omitempty" norman:"required"`
	Secret           string `json:"secret,omitempty" norman:"type=password,required"`
	Agent            string `json:"agent,omitempty" norman:"required"`
	Corp             string `json:"corp,omitempty" norman:"required"`
	RecipientType    string `json:"recipientType,omitempty" norman:"required,options=tag|party|user,default=party"`
	APIURL           string `json:"apiUrl,omitempty"`
	*HTTPClientConfig
}

func (*WechatConfig) DeepCopy 

func (in *WechatConfig) DeepCopy() *WechatConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WechatConfig.

func (*WechatConfig) DeepCopyInto 

func (in *WechatConfig) DeepCopyInto(out *WechatConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WindowsSystemImages 

type WindowsSystemImages struct {
	// Windows nginx-proxy image
	NginxProxy string `yaml:"nginx_proxy" json:"nginxProxy,omitempty"`
	// Kubernetes binaries image
	KubernetesBinaries string `yaml:"kubernetes_binaries" json:"kubernetesBinaries,omitempty"`
	// Kubelet pause image
	KubeletPause string `yaml:"kubelet_pause" json:"kubeletPause,omitempty"`
	// Flannel CNI binaries image
	FlannelCNIBinaries string `yaml:"flannel_cni_binaries" json:"flannelCniBinaries,omitempty"`
	// Calico CNI binaries image
	CalicoCNIBinaries string `yaml:"calico_cni_binaries" json:"calicoCniBinaries,omitempty"`
	// Canal CNI binaries image
	CanalCNIBinaries string `yaml:"canal_cni_binaries" json:"canalCniBinaries,omitempty"`
}

func (*WindowsSystemImages) DeepCopy 

func (in *WindowsSystemImages) DeepCopy() *WindowsSystemImages

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WindowsSystemImages.

func (*WindowsSystemImages) DeepCopyInto 

func (in *WindowsSystemImages) DeepCopyInto(out *WindowsSystemImages)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WorkloadRule 

type WorkloadRule struct {
	WorkloadID          string            `json:"workloadId,omitempty"`
	Selector            map[string]string `json:"selector,omitempty"`
	AvailablePercentage int               `json:"availablePercentage,omitempty" norman:"required,min=1,max=100,default=70"`
}

func (*WorkloadRule) DeepCopy 

func (in *WorkloadRule) DeepCopy() *WorkloadRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadRule.

func (*WorkloadRule) DeepCopyInto 

func (in *WorkloadRule) DeepCopyInto(out *WorkloadRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WorkspaceVsphereOpts 

type WorkspaceVsphereOpts struct {
	VCenterIP        string `json:"server,omitempty" yaml:"server,omitempty" ini:"server,omitempty"`
	Datacenter       string `json:"datacenter,omitempty" yaml:"datacenter,omitempty" ini:"datacenter,omitempty"`
	Folder           string `json:"folder,omitempty" yaml:"folder,omitempty" ini:"folder,omitempty"`
	DefaultDatastore string `json:"default-datastore,omitempty" yaml:"default-datastore,omitempty" ini:"default-datastore,omitempty"`
	ResourcePoolPath string `json:"resourcepool-path,omitempty" yaml:"resourcepool-path,omitempty" ini:"resourcepool-path,omitempty"`
}

func (*WorkspaceVsphereOpts) DeepCopy 

func (in *WorkspaceVsphereOpts) DeepCopy() *WorkspaceVsphereOpts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkspaceVsphereOpts.

func (*WorkspaceVsphereOpts) DeepCopyInto 

func (in *WorkspaceVsphereOpts) DeepCopyInto(out *WorkspaceVsphereOpts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type YAxis 

type YAxis struct {
	Unit string `json:"unit,omitempty"`
}

func (*YAxis) DeepCopy 

func (in *YAxis) DeepCopy() *YAxis

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new YAxis.

func (*YAxis) DeepCopyInto 

func (in *YAxis) DeepCopyInto(out *YAxis)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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