v3

package
v0.0.0-...-7c47f85 Latest Latest
Warning

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

Go to latest
Published: Jul 3, 2019 License: Apache-2.0 Imports: 29 Imported by: 0

Documentation

Index

Constants

View Source
const (
	BackupConditionCreated   condition.Cond = "Created"
	BackupConditionCompleted condition.Cond = "Completed"
	BackupConditionRestored  condition.Cond = "Restored"
)
View Source
const (
	ClusterScanConditionCreated   condition.Cond = "Created"
	ClusterScanConditionCompleted condition.Cond = "Completed"
)
View Source
const (
	ClusterActionGenerateKubeconfig    = "generateKubeconfig"
	ClusterActionImportYaml            = "importYaml"
	ClusterActionExportYaml            = "exportYaml"
	ClusterActionViewMonitoring        = "viewMonitoring"
	ClusterActionEditMonitoring        = "editMonitoring"
	ClusterActionEnableMonitoring      = "enableMonitoring"
	ClusterActionDisableMonitoring     = "disableMonitoring"
	ClusterActionBackupEtcd            = "backupEtcd"
	ClusterActionRestoreFromEtcdBackup = "restoreFromEtcdBackup"
	ClusterActionRotateCertificates    = "rotateCertificates"
	ClusterActionRunCISScan            = "runSecurityScan"

	// 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"
	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"

	ClusterDriverImported = "imported"
	ClusterDriverLocal    = "local"
	ClusterDriverRKE      = "rancherKubernetesEngine"
	ClusterDriverGKE      = "googleKubernetesEngine"
	ClusterDriverEKS      = "amazonElasticContainerService"
	ClusterDriverAKS      = "azureKubernetesService"
)
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 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"
)
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"
)
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 (
	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 (
	ListenConfigGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "ListenConfig",
	}
	ListenConfigResource = metav1.APIResource{
		Name:         "listenconfigs",
		SingularName: "listenconfig",
		Namespaced:   false,
		Kind:         ListenConfigGroupVersionKind.Kind,
	}

	ListenConfigGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "listenconfigs",
	}
)
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 (
	RKEK8sWindowsSystemImageGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "RKEK8sWindowsSystemImage",
	}
	RKEK8sWindowsSystemImageResource = metav1.APIResource{
		Name:         "rkek8swindowssystemimages",
		SingularName: "rkek8swindowssystemimage",
		Namespaced:   true,

		Kind: RKEK8sWindowsSystemImageGroupVersionKind.Kind,
	}

	RKEK8sWindowsSystemImageGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "rkek8swindowssystemimages",
	}
)
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 (
	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 {
		AlertSystemImages    AlertSystemImages
		PipelineSystemImages projectv3.PipelineSystemImages
		LoggingSystemImages  LoggingSystemImages
		AuthSystemImages     AuthSystemImages
	}{
		AlertSystemImages: AlertSystemImages{
			AlertManager:       m("prom/alertmanager:v0.15.2"),
			AlertManagerHelper: m("rancher/alertmanager-helper:v0.0.2"),
		},
		PipelineSystemImages: projectv3.PipelineSystemImages{
			Jenkins:       m("rancher/pipeline-jenkins-server:v0.1.0"),
			JenkinsJnlp:   m("jenkins/jnlp-slave:3.10-1-alpine"),
			AlpineGit:     m("rancher/pipeline-tools:v0.1.9"),
			PluginsDocker: m("plugins/docker:17.12"),
			Minio:         m("minio/minio:RELEASE.2018-05-25T19-49-13Z"),
			Registry:      m("registry:2"),
			RegistryProxy: m("rancher/pipeline-tools:v0.1.9"),
			KubeApply:     m("rancher/pipeline-tools:v0.1.9"),
		},
		LoggingSystemImages: LoggingSystemImages{
			Fluentd:                       m("rancher/fluentd:v0.1.11"),
			FluentdHelper:                 m("rancher/fluentd-helper:v0.1.2"),
			LogAggregatorFlexVolumeDriver: m("rancher/log-aggregator:v0.1.4"),
		},
		AuthSystemImages: AuthSystemImages{
			KubeAPIAuth: m("rancher/kube-api-auth:v0.1.3"),
		},
	}
)

Functions

func Factory

func Factory(ctx context.Context, config rest.Config) (context.Context, controller.Starter, error)

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"`
	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

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

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

func (*ActiveDirectoryTestAndApplyInput) DeepCopyInto

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 AlertSystemImages

type AlertSystemImages struct {
	AlertManager       string `json:"alertManager,omitempty"`
	AlertManagerHelper string `json:"alertManagerHelper,omitempty"`
}

func (*AlertSystemImages) DeepCopy

func (in *AlertSystemImages) DeepCopy() *AlertSystemImages

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

func (*AlertSystemImages) DeepCopyInto

func (in *AlertSystemImages) DeepCopyInto(out *AlertSystemImages)

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"`
}

func (*AlidnsProviderConfig) DeepCopy

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.

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 AuthConfigClient

type AuthConfigClient interface {
	Create(*AuthConfig) (*AuthConfig, error)
	Get(namespace, name string, opts metav1.GetOptions) (*AuthConfig, error)
	Update(*AuthConfig) (*AuthConfig, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*AuthConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() AuthConfigClientCache

	OnCreate(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() AuthConfigInterface
}

type AuthConfigClientCache

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

	Index(name string, indexer AuthConfigIndexer)
	GetIndexed(name, key string) ([]*AuthConfig, 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)
	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 AuthConfigIndexer

type AuthConfigIndexer func(obj *AuthConfig) ([]string, error)

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)
	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

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

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"`
}

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"`
}

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

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

func (*BlockStorageOpenstackOpts) DeepCopyInto

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

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

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"`
}

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 CatalogClient

type CatalogClient interface {
	Create(*Catalog) (*Catalog, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Catalog, error)
	Update(*Catalog) (*Catalog, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*CatalogList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() CatalogClientCache

	OnCreate(ctx context.Context, name string, sync CatalogChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync CatalogChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync CatalogChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() CatalogInterface
}

type CatalogClientCache

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

	Index(name string, indexer CatalogIndexer)
	GetIndexed(name, key string) ([]*Catalog, 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)
	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 CatalogIndexer

type CatalogIndexer func(obj *Catalog) ([]string, error)

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)
	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 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"`
}

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"`
}

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 CatalogTemplateClient

type CatalogTemplateClient interface {
	Create(*CatalogTemplate) (*CatalogTemplate, error)
	Get(namespace, name string, opts metav1.GetOptions) (*CatalogTemplate, error)
	Update(*CatalogTemplate) (*CatalogTemplate, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*CatalogTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() CatalogTemplateClientCache

	OnCreate(ctx context.Context, name string, sync CatalogTemplateChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync CatalogTemplateChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync CatalogTemplateChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() CatalogTemplateInterface
}

type CatalogTemplateClientCache

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

	Index(name string, indexer CatalogTemplateIndexer)
	GetIndexed(name, key string) ([]*CatalogTemplate, 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)
	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 CatalogTemplateIndexer

type CatalogTemplateIndexer func(obj *CatalogTemplate) ([]string, error)

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)
	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

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 CatalogTemplateVersionClientCache

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

	Index(name string, indexer CatalogTemplateVersionIndexer)
	GetIndexed(name, key string) ([]*CatalogTemplateVersion, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type CatalogTemplateVersionHandlerFunc

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

type CatalogTemplateVersionIndexer

type CatalogTemplateVersionIndexer func(obj *CatalogTemplateVersion) ([]string, error)

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)
	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

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

func (*CatalogTemplateVersionList) DeepCopyInto

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 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) 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) ListenConfigs

func (c *Client) ListenConfigs(namespace string) ListenConfigInterface

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) RKEK8sWindowsSystemImages

func (c *Client) RKEK8sWindowsSystemImages(namespace string) RKEK8sWindowsSystemImageInterface

func (*Client) RoleTemplates

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

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 Clients

type Clients struct {
	Interface Interface

	NodePool                                NodePoolClient
	Node                                    NodeClient
	NodeDriver                              NodeDriverClient
	NodeTemplate                            NodeTemplateClient
	Project                                 ProjectClient
	GlobalRole                              GlobalRoleClient
	GlobalRoleBinding                       GlobalRoleBindingClient
	RoleTemplate                            RoleTemplateClient
	PodSecurityPolicyTemplate               PodSecurityPolicyTemplateClient
	PodSecurityPolicyTemplateProjectBinding PodSecurityPolicyTemplateProjectBindingClient
	ClusterRoleTemplateBinding              ClusterRoleTemplateBindingClient
	ProjectRoleTemplateBinding              ProjectRoleTemplateBindingClient
	Cluster                                 ClusterClient
	ClusterRegistrationToken                ClusterRegistrationTokenClient
	Catalog                                 CatalogClient
	Template                                TemplateClient
	CatalogTemplate                         CatalogTemplateClient
	CatalogTemplateVersion                  CatalogTemplateVersionClient
	TemplateVersion                         TemplateVersionClient
	TemplateContent                         TemplateContentClient
	Group                                   GroupClient
	GroupMember                             GroupMemberClient
	Principal                               PrincipalClient
	User                                    UserClient
	AuthConfig                              AuthConfigClient
	LdapConfig                              LdapConfigClient
	Token                                   TokenClient
	DynamicSchema                           DynamicSchemaClient
	Preference                              PreferenceClient
	UserAttribute                           UserAttributeClient
	ProjectNetworkPolicy                    ProjectNetworkPolicyClient
	ClusterLogging                          ClusterLoggingClient
	ProjectLogging                          ProjectLoggingClient
	ListenConfig                            ListenConfigClient
	Setting                                 SettingClient
	Feature                                 FeatureClient
	ClusterAlert                            ClusterAlertClient
	ProjectAlert                            ProjectAlertClient
	Notifier                                NotifierClient
	ClusterAlertGroup                       ClusterAlertGroupClient
	ProjectAlertGroup                       ProjectAlertGroupClient
	ClusterAlertRule                        ClusterAlertRuleClient
	ProjectAlertRule                        ProjectAlertRuleClient
	ComposeConfig                           ComposeConfigClient
	ProjectCatalog                          ProjectCatalogClient
	ClusterCatalog                          ClusterCatalogClient
	MultiClusterApp                         MultiClusterAppClient
	MultiClusterAppRevision                 MultiClusterAppRevisionClient
	GlobalDNS                               GlobalDNSClient
	GlobalDNSProvider                       GlobalDNSProviderClient
	KontainerDriver                         KontainerDriverClient
	EtcdBackup                              EtcdBackupClient
	ClusterScan                             ClusterScanClient
	MonitorMetric                           MonitorMetricClient
	ClusterMonitorGraph                     ClusterMonitorGraphClient
	ProjectMonitorGraph                     ProjectMonitorGraphClient
	CloudCredential                         CloudCredentialClient
	ClusterTemplate                         ClusterTemplateClient
	ClusterTemplateRevision                 ClusterTemplateRevisionClient
	RKEK8sSystemImage                       RKEK8sSystemImageClient
	RKEK8sServiceOption                     RKEK8sServiceOptionClient
	RKEAddon                                RKEAddonClient
	RKEK8sWindowsSystemImage                RKEK8sWindowsSystemImageClient
}

func ClientsFrom

func ClientsFrom(ctx context.Context) *Clients

func NewClients

func NewClients(config rest.Config) (*Clients, error)

func NewClientsFromInterface

func NewClientsFromInterface(iface Interface) *Clients

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 CloudCredentialClient

type CloudCredentialClient interface {
	Create(*CloudCredential) (*CloudCredential, error)
	Get(namespace, name string, opts metav1.GetOptions) (*CloudCredential, error)
	Update(*CloudCredential) (*CloudCredential, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*CloudCredentialList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() CloudCredentialClientCache

	OnCreate(ctx context.Context, name string, sync CloudCredentialChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync CloudCredentialChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync CloudCredentialChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() CloudCredentialInterface
}

type CloudCredentialClientCache

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

	Index(name string, indexer CloudCredentialIndexer)
	GetIndexed(name, key string) ([]*CloudCredential, 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)
	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 CloudCredentialIndexer

type CloudCredentialIndexer func(obj *CloudCredential) ([]string, error)

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)
	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 {
	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"`
}

func (*CloudflareProviderConfig) DeepCopy

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.

type ClusterAlertChangeHandlerFunc

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

type ClusterAlertClient

type ClusterAlertClient interface {
	Create(*ClusterAlert) (*ClusterAlert, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterAlert, error)
	Update(*ClusterAlert) (*ClusterAlert, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterAlertList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterAlertClientCache

	OnCreate(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterAlertInterface
}

type ClusterAlertClientCache

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

	Index(name string, indexer ClusterAlertIndexer)
	GetIndexed(name, key string) ([]*ClusterAlert, 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)
	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.

type ClusterAlertGroupChangeHandlerFunc

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

type ClusterAlertGroupClient

type ClusterAlertGroupClient interface {
	Create(*ClusterAlertGroup) (*ClusterAlertGroup, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterAlertGroup, error)
	Update(*ClusterAlertGroup) (*ClusterAlertGroup, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterAlertGroupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterAlertGroupClientCache

	OnCreate(ctx context.Context, name string, sync ClusterAlertGroupChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterAlertGroupChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterAlertGroupChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterAlertGroupInterface
}

type ClusterAlertGroupClientCache

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

	Index(name string, indexer ClusterAlertGroupIndexer)
	GetIndexed(name, key string) ([]*ClusterAlertGroup, 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)
	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 ClusterAlertGroupIndexer

type ClusterAlertGroupIndexer func(obj *ClusterAlertGroup) ([]string, error)

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)
	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

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 ClusterAlertIndexer

type ClusterAlertIndexer func(obj *ClusterAlert) ([]string, error)

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)
	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.

type ClusterAlertRuleChangeHandlerFunc

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

type ClusterAlertRuleClient

type ClusterAlertRuleClient interface {
	Create(*ClusterAlertRule) (*ClusterAlertRule, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterAlertRule, error)
	Update(*ClusterAlertRule) (*ClusterAlertRule, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterAlertRuleList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterAlertRuleClientCache

	OnCreate(ctx context.Context, name string, sync ClusterAlertRuleChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterAlertRuleChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterAlertRuleChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterAlertRuleInterface
}

type ClusterAlertRuleClientCache

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

	Index(name string, indexer ClusterAlertRuleIndexer)
	GetIndexed(name, key string) ([]*ClusterAlertRule, 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)
	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 ClusterAlertRuleIndexer

type ClusterAlertRuleIndexer func(obj *ClusterAlertRule) ([]string, error)

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)
	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

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"`
}

func (*ClusterAlertRuleSpec) DeepCopy

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.

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.

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 ClusterCatalogClient

type ClusterCatalogClient interface {
	Create(*ClusterCatalog) (*ClusterCatalog, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterCatalog, error)
	Update(*ClusterCatalog) (*ClusterCatalog, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterCatalogList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterCatalogClientCache

	OnCreate(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterCatalogInterface
}

type ClusterCatalogClientCache

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

	Index(name string, indexer ClusterCatalogIndexer)
	GetIndexed(name, key string) ([]*ClusterCatalog, 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)
	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 ClusterCatalogIndexer

type ClusterCatalogIndexer func(obj *ClusterCatalog) ([]string, error)

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)
	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 ClusterClient

type ClusterClient interface {
	Create(*Cluster) (*Cluster, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Cluster, error)
	Update(*Cluster) (*Cluster, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterClientCache

	OnCreate(ctx context.Context, name string, sync ClusterChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterInterface
}

type ClusterClientCache

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

	Index(name string, indexer ClusterIndexer)
	GetIndexed(name, key string) ([]*Cluster, 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

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)
	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.

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 ClusterIndexer

type ClusterIndexer func(obj *Cluster) ([]string, error)

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)
	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.

type ClusterLoggingChangeHandlerFunc

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

type ClusterLoggingClient

type ClusterLoggingClient interface {
	Create(*ClusterLogging) (*ClusterLogging, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterLogging, error)
	Update(*ClusterLogging) (*ClusterLogging, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterLoggingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterLoggingClientCache

	OnCreate(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterLoggingInterface
}

type ClusterLoggingClientCache

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

	Index(name string, indexer ClusterLoggingIndexer)
	GetIndexed(name, key string) ([]*ClusterLogging, 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)
	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 ClusterLoggingIndexer

type ClusterLoggingIndexer func(obj *ClusterLogging) ([]string, error)

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)
	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.

type ClusterLoggingStatus

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

func (*ClusterLoggingStatus) DeepCopy

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

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.

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.

type ClusterMonitorGraphChangeHandlerFunc

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

type ClusterMonitorGraphClient

type ClusterMonitorGraphClient interface {
	Create(*ClusterMonitorGraph) (*ClusterMonitorGraph, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterMonitorGraph, error)
	Update(*ClusterMonitorGraph) (*ClusterMonitorGraph, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterMonitorGraphList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterMonitorGraphClientCache

	OnCreate(ctx context.Context, name string, sync ClusterMonitorGraphChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterMonitorGraphChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterMonitorGraphChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterMonitorGraphInterface
}

type ClusterMonitorGraphClientCache

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

	Index(name string, indexer ClusterMonitorGraphIndexer)
	GetIndexed(name, key string) ([]*ClusterMonitorGraph, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterMonitorGraphHandlerFunc

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

type ClusterMonitorGraphIndexer

type ClusterMonitorGraphIndexer func(obj *ClusterMonitorGraph) ([]string, error)

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)
	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

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

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.

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

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.

type ClusterRegistrationTokenChangeHandlerFunc

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

type ClusterRegistrationTokenClientCache

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

	Index(name string, indexer ClusterRegistrationTokenIndexer)
	GetIndexed(name, key string) ([]*ClusterRegistrationToken, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterRegistrationTokenHandlerFunc

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

type ClusterRegistrationTokenIndexer

type ClusterRegistrationTokenIndexer func(obj *ClusterRegistrationToken) ([]string, error)

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)
	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

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

func (*ClusterRegistrationTokenList) DeepCopyInto

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

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

func (*ClusterRegistrationTokenSpec) DeepCopyInto

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

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

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

func (*ClusterRegistrationTokenStatus) DeepCopyInto

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:"type=reference[user]"`
	UserPrincipalName  string `json:"userPrincipalName,omitempty" norman:"type=reference[principal]"`
	GroupName          string `json:"groupName,omitempty" norman:"type=reference[group]"`
	GroupPrincipalName string `json:"groupPrincipalName,omitempty" norman:"type=reference[principal]"`
	ClusterName        string `json:"clusterName,omitempty" norman:"required,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

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

func (*ClusterRoleTemplateBinding) DeepCopyInto

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.

type ClusterRoleTemplateBindingChangeHandlerFunc

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

type ClusterRoleTemplateBindingClientCache

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

	Index(name string, indexer ClusterRoleTemplateBindingIndexer)
	GetIndexed(name, key string) ([]*ClusterRoleTemplateBinding, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterRoleTemplateBindingHandlerFunc

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

type ClusterRoleTemplateBindingIndexer

type ClusterRoleTemplateBindingIndexer func(obj *ClusterRoleTemplateBinding) ([]string, error)

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)
	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

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

func (*ClusterRoleTemplateBindingList) DeepCopyInto

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 ClusterScanClient

type ClusterScanClient interface {
	Create(*ClusterScan) (*ClusterScan, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterScan, error)
	Update(*ClusterScan) (*ClusterScan, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterScanList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterScanClientCache

	OnCreate(ctx context.Context, name string, sync ClusterScanChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterScanChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterScanChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterScanInterface
}

type ClusterScanClientCache

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

	Index(name string, indexer ClusterScanIndexer)
	GetIndexed(name, key string) ([]*ClusterScan, 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

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 {
}

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)
	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 ClusterScanIndexer

type ClusterScanIndexer func(obj *ClusterScan) ([]string, error)

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)
	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 ClusterScanSpec

type ClusterScanSpec struct {
	ScanType string `json:"scanType"`
	// cluster ID
	ClusterID string `json:"clusterId,omitempty" norman:"required,type=reference[cluster]"`
	// manual flag
	Manual bool `yaml:"manual" json:"manual,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"`
}

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"`
	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]"`
	ClusterTemplateRevisionName         string              `json:"clusterTemplateRevisionName,omitempty" norman:"type=reference[clusterTemplateRevision]"`
	ClusterTemplateAnswers              Answer              `json:"answers,omitempty"`
}

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"`
	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"`
	LocalClusterAuthEndpoint             LocalClusterAuthEndpoint       `json:"localClusterAuthEndpoint,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"`
	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"`
	IstioEnabled                         bool                      `json:"istioEnabled,omitempty" norman:"nocreate,noupdate,default=false"`
	CertificatesExpiration               map[string]CertExpiration `json:"certificatesExpiration,omitempty"`
}

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 ClusterTemplateClient

type ClusterTemplateClient interface {
	Create(*ClusterTemplate) (*ClusterTemplate, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ClusterTemplate, error)
	Update(*ClusterTemplate) (*ClusterTemplate, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ClusterTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ClusterTemplateClientCache

	OnCreate(ctx context.Context, name string, sync ClusterTemplateChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ClusterTemplateChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ClusterTemplateChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ClusterTemplateInterface
}

type ClusterTemplateClientCache

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

	Index(name string, indexer ClusterTemplateIndexer)
	GetIndexed(name, key string) ([]*ClusterTemplate, 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)
	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 ClusterTemplateIndexer

type ClusterTemplateIndexer func(obj *ClusterTemplate) ([]string, error)

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)
	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

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

func (*ClusterTemplateQuestionsOutput) DeepCopyInto

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"`
}

func NewClusterTemplateRevision

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

func (*ClusterTemplateRevision) DeepCopy

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 ClusterTemplateRevisionClientCache

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

	Index(name string, indexer ClusterTemplateRevisionIndexer)
	GetIndexed(name, key string) ([]*ClusterTemplateRevision, error)
}

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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ClusterTemplateRevisionHandlerFunc

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

type ClusterTemplateRevisionIndexer

type ClusterTemplateRevisionIndexer func(obj *ClusterTemplateRevision) ([]string, error)

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)
	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

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

func (*ClusterTemplateRevisionList) DeepCopyInto

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 {
	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

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

func (*ClusterTemplateRevisionSpec) DeepCopyInto

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"`
	Enabled             *bool  `json:"enabled,omitempty" norman:"default=true"`
	Enforced            bool   `json:"enforced,omitempty"`
	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.

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

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

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 ComposeConfigClient

type ComposeConfigClient interface {
	Create(*ComposeConfig) (*ComposeConfig, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ComposeConfig, error)
	Update(*ComposeConfig) (*ComposeConfig, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ComposeConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ComposeConfigClientCache

	OnCreate(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ComposeConfigInterface
}

type ComposeConfigClientCache

type ComposeConfigClientCache interface {
	Get(namespace, name string) (*ComposeConfig, error)
	List(namespace string, selector labels.Selector) ([]*ComposeConfig, error)

	Index(name string, indexer ComposeConfigIndexer)
	GetIndexed(name, key string) ([]*ComposeConfig, 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)
	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 ComposeConfigIndexer

type ComposeConfigIndexer func(obj *ComposeConfig) ([]string, error)

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)
	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 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

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"`
}

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"`
}

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 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
	DockerRootDir      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 DynamicSchemaClient

type DynamicSchemaClient interface {
	Create(*DynamicSchema) (*DynamicSchema, error)
	Get(namespace, name string, opts metav1.GetOptions) (*DynamicSchema, error)
	Update(*DynamicSchema) (*DynamicSchema, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*DynamicSchemaList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() DynamicSchemaClientCache

	OnCreate(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() DynamicSchemaInterface
}

type DynamicSchemaClientCache

type DynamicSchemaClientCache interface {
	Get(namespace, name string) (*DynamicSchema, error)
	List(namespace string, selector labels.Selector) ([]*DynamicSchema, error)

	Index(name string, indexer DynamicSchemaIndexer)
	GetIndexed(name, key string) ([]*DynamicSchema, 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)
	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 DynamicSchemaIndexer

type DynamicSchemaIndexer func(obj *DynamicSchema) ([]string, error)

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)
	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"`
	// 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 EtcdBackupClient

type EtcdBackupClient interface {
	Create(*EtcdBackup) (*EtcdBackup, error)
	Get(namespace, name string, opts metav1.GetOptions) (*EtcdBackup, error)
	Update(*EtcdBackup) (*EtcdBackup, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*EtcdBackupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() EtcdBackupClientCache

	OnCreate(ctx context.Context, name string, sync EtcdBackupChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync EtcdBackupChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync EtcdBackupChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() EtcdBackupInterface
}

type EtcdBackupClientCache

type EtcdBackupClientCache interface {
	Get(namespace, name string) (*EtcdBackup, error)
	List(namespace string, selector labels.Selector) ([]*EtcdBackup, error)

	Index(name string, indexer EtcdBackupIndexer)
	GetIndexed(name, key string) ([]*EtcdBackup, 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)
	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 EtcdBackupIndexer

type EtcdBackupIndexer func(obj *EtcdBackup) ([]string, error)

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)
	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]"`
	// manual backup flag
	Manual bool `yaml:"manual" json:"manual,omitempty"`
	// actual file name on the target
	Filename string `yaml:"filename" json:"filename,omitempty"`
	// backupConfig
	BackupConfig BackupConfig `yaml:",omitempty" json:"backupConfig,omitempty"`
}

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"`
}

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 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 Feature

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

	Value   *bool `json:"value" norman:"required"`
	Default bool  `json:"default" norman:"nocreate,noupdate"`
}

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 FeatureClient

type FeatureClient interface {
	Create(*Feature) (*Feature, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Feature, error)
	Update(*Feature) (*Feature, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*FeatureList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() FeatureClientCache

	OnCreate(ctx context.Context, name string, sync FeatureChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync FeatureChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync FeatureChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() FeatureInterface
}

type FeatureClientCache

type FeatureClientCache interface {
	Get(namespace, name string) (*Feature, error)
	List(namespace string, selector labels.Selector) ([]*Feature, error)

	Index(name string, indexer FeatureIndexer)
	GetIndexed(name, key string) ([]*Feature, 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)
	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 FeatureIndexer

type FeatureIndexer func(obj *Feature) ([]string, error)

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)
	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 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

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"`
	Compress      bool           `json:"compress,omitempty" norman:"default=true"`
	FluentServers []FluentServer `json:"fluentServers,omitempty" norman:"required"`
}

func (*FluentForwarderConfig) DeepCopy

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

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

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"`
}

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

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

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 GlobalDNSClient

type GlobalDNSClient interface {
	Create(*GlobalDNS) (*GlobalDNS, error)
	Get(namespace, name string, opts metav1.GetOptions) (*GlobalDNS, error)
	Update(*GlobalDNS) (*GlobalDNS, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*GlobalDNSList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() GlobalDNSClientCache

	OnCreate(ctx context.Context, name string, sync GlobalDNSChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync GlobalDNSChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync GlobalDNSChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() GlobalDNSInterface
}

type GlobalDNSClientCache

type GlobalDNSClientCache interface {
	Get(namespace, name string) (*GlobalDNS, error)
	List(namespace string, selector labels.Selector) ([]*GlobalDNS, error)

	Index(name string, indexer GlobalDNSIndexer)
	GetIndexed(name, key string) ([]*GlobalDNS, 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)
	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 GlobalDNSIndexer

type GlobalDNSIndexer func(obj *GlobalDNS) ([]string, error)

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)
	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 GlobalDNSProviderClient

type GlobalDNSProviderClient interface {
	Create(*GlobalDNSProvider) (*GlobalDNSProvider, error)
	Get(namespace, name string, opts metav1.GetOptions) (*GlobalDNSProvider, error)
	Update(*GlobalDNSProvider) (*GlobalDNSProvider, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*GlobalDNSProviderList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() GlobalDNSProviderClientCache

	OnCreate(ctx context.Context, name string, sync GlobalDNSProviderChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync GlobalDNSProviderChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync GlobalDNSProviderChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() GlobalDNSProviderInterface
}

type GlobalDNSProviderClientCache

type GlobalDNSProviderClientCache interface {
	Get(namespace, name string) (*GlobalDNSProvider, error)
	List(namespace string, selector labels.Selector) ([]*GlobalDNSProvider, error)

	Index(name string, indexer GlobalDNSProviderIndexer)
	GetIndexed(name, key string) ([]*GlobalDNSProvider, 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)
	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 GlobalDNSProviderIndexer

type GlobalDNSProviderIndexer func(obj *GlobalDNSProvider) ([]string, error)

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)
	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

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

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,noupdate"`
	Description    string              `json:"description" norman:"noupdate"`
	Rules          []rbacv1.PolicyRule `json:"rules,omitempty" norman:"noupdate"`
	NewUserDefault bool                `json:"newUserDefault,omitempty" norman:"required"`
}

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:"required,type=reference[user]"`
	GlobalRoleName string `json:"globalRoleName,omitempty" norman:"required,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 GlobalRoleBindingClient

type GlobalRoleBindingClient interface {
	Create(*GlobalRoleBinding) (*GlobalRoleBinding, error)
	Get(namespace, name string, opts metav1.GetOptions) (*GlobalRoleBinding, error)
	Update(*GlobalRoleBinding) (*GlobalRoleBinding, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*GlobalRoleBindingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() GlobalRoleBindingClientCache

	OnCreate(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() GlobalRoleBindingInterface
}

type GlobalRoleBindingClientCache

type GlobalRoleBindingClientCache interface {
	Get(namespace, name string) (*GlobalRoleBinding, error)
	List(namespace string, selector labels.Selector) ([]*GlobalRoleBinding, error)

	Index(name string, indexer GlobalRoleBindingIndexer)
	GetIndexed(name, key string) ([]*GlobalRoleBinding, 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)
	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 GlobalRoleBindingIndexer

type GlobalRoleBindingIndexer func(obj *GlobalRoleBinding) ([]string, error)

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)
	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

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 GlobalRoleClient

type GlobalRoleClient interface {
	Create(*GlobalRole) (*GlobalRole, error)
	Get(namespace, name string, opts metav1.GetOptions) (*GlobalRole, error)
	Update(*GlobalRole) (*GlobalRole, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*GlobalRoleList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() GlobalRoleClientCache

	OnCreate(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() GlobalRoleInterface
}

type GlobalRoleClientCache

type GlobalRoleClientCache interface {
	Get(namespace, name string) (*GlobalRole, error)
	List(namespace string, selector labels.Selector) ([]*GlobalRole, error)

	Index(name string, indexer GlobalRoleIndexer)
	GetIndexed(name, key string) ([]*GlobalRole, 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)
	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 GlobalRoleIndexer

type GlobalRoleIndexer func(obj *GlobalRole) ([]string, error)

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)
	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"`
}

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

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

func (*GoogleOauthConfigApplyInput) DeepCopyInto

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

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

func (*GoogleOauthConfigTestOutput) DeepCopyInto

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 GroupClient

type GroupClient interface {
	Create(*Group) (*Group, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Group, error)
	Update(*Group) (*Group, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*GroupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() GroupClientCache

	OnCreate(ctx context.Context, name string, sync GroupChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync GroupChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync GroupChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() GroupInterface
}

type GroupClientCache

type GroupClientCache interface {
	Get(namespace, name string) (*Group, error)
	List(namespace string, selector labels.Selector) ([]*Group, error)

	Index(name string, indexer GroupIndexer)
	GetIndexed(name, key string) ([]*Group, 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)
	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 GroupIndexer

type GroupIndexer func(obj *Group) ([]string, error)

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)
	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 GroupMemberClient

type GroupMemberClient interface {
	Create(*GroupMember) (*GroupMember, error)
	Get(namespace, name string, opts metav1.GetOptions) (*GroupMember, error)
	Update(*GroupMember) (*GroupMember, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*GroupMemberList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() GroupMemberClientCache

	OnCreate(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() GroupMemberInterface
}

type GroupMemberClientCache

type GroupMemberClientCache interface {
	Get(namespace, name string) (*GroupMember, error)
	List(namespace string, selector labels.Selector) ([]*GroupMember, error)

	Index(name string, indexer GroupMemberIndexer)
	GetIndexed(name, key string) ([]*GroupMember, 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)
	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 GroupMemberIndexer

type GroupMemberIndexer func(obj *GroupMember) ([]string, error)

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)
	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

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.

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"`
}

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

func From

func From(ctx context.Context) Interface

func NewForConfig

func NewForConfig(config rest.Config) (Interface, error)

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 KontainerDriverClient

type KontainerDriverClient interface {
	Create(*KontainerDriver) (*KontainerDriver, error)
	Get(namespace, name string, opts metav1.GetOptions) (*KontainerDriver, error)
	Update(*KontainerDriver) (*KontainerDriver, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*KontainerDriverList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() KontainerDriverClientCache

	OnCreate(ctx context.Context, name string, sync KontainerDriverChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync KontainerDriverChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync KontainerDriverChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() KontainerDriverInterface
}

type KontainerDriverClientCache

type KontainerDriverClientCache interface {
	Get(namespace, name string) (*KontainerDriver, error)
	List(namespace string, selector labels.Selector) ([]*KontainerDriver, error)

	Index(name string, indexer KontainerDriverIndexer)
	GetIndexed(name, key string) ([]*KontainerDriver, 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)
	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 KontainerDriverIndexer

type KontainerDriverIndexer func(obj *KontainerDriver) ([]string, error)

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)
	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

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"`
}

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

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"`
}

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 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

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

func (*KubernetesServicesOptions) DeepCopyInto

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"`

	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"`
	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"`
	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"`
	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 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 LdapConfigClient

type LdapConfigClient interface {
	Create(*LdapConfig) (*LdapConfig, error)
	Get(namespace, name string, opts metav1.GetOptions) (*LdapConfig, error)
	Update(*LdapConfig) (*LdapConfig, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*LdapConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() LdapConfigClientCache

	OnCreate(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() LdapConfigInterface
}

type LdapConfigClientCache

type LdapConfigClientCache interface {
	Get(namespace, name string) (*LdapConfig, error)
	List(namespace string, selector labels.Selector) ([]*LdapConfig, error)

	Index(name string, indexer LdapConfigIndexer)
	GetIndexed(name, key string) ([]*LdapConfig, 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)
	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 LdapConfigIndexer

type LdapConfigIndexer func(obj *LdapConfig) ([]string, error)

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)
	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 LdapTestAndApplyInput

type LdapTestAndApplyInput struct {
	LdapConfig `json:"ldapConfig,omitempty"`
	Username   string `json:"username"`
	Password   string `json:"password" norman:"type=password,required"`
}

func (*LdapTestAndApplyInput) DeepCopy

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 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 ListenConfig

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

	DisplayName    string            `json:"displayName,omitempty"`
	Description    string            `json:"description,omitempty"`
	Mode           string            `json:"mode,omitempty" norman:"type=enum,options=https|http|acme"`
	CACerts        string            `json:"caCerts,omitempty"`
	CACert         string            `json:"caCert,omitempty"`
	CAKey          string            `json:"caKey,omitempty"`
	Cert           string            `json:"cert,omitempty"`
	Key            string            `json:"key,omitempty" norman:"writeOnly"`
	Domains        []string          `json:"domains,omitempty"`
	TOS            []string          `json:"tos,omitempty" norman:"default=auto"`
	KnownIPs       []string          `json:"knownIps" norman:"nocreate,noupdate"`
	GeneratedCerts map[string]string `json:"generatedCerts" norman:"nocreate,noupdate"`
	Enabled        bool              `json:"enabled,omitempty" norman:"default=true"`

	CertFingerprint         string   `json:"certFingerprint,omitempty" norman:"nocreate,noupdate"`
	CN                      string   `json:"cn,omitempty" norman:"nocreate,noupdate"`
	Version                 int      `json:"version,omitempty" norman:"nocreate,noupdate"`
	ExpiresAt               string   `json:"expiresAt,omitempty" norman:"nocreate,noupdate"`
	Issuer                  string   `json:"issuer,omitempty" norman:"nocreate,noupdate"`
	IssuedAt                string   `json:"issuedAt,omitempty" norman:"nocreate,noupdate"`
	Algorithm               string   `json:"algorithm,omitempty" norman:"nocreate,noupdate"`
	SerialNumber            string   `json:"serialNumber,omitempty" norman:"nocreate,noupdate"`
	KeySize                 int      `json:"keySize,omitempty" norman:"nocreate,noupdate"`
	SubjectAlternativeNames []string `json:"subjectAlternativeNames,omitempty" norman:"nocreate,noupdate"`
}

func NewListenConfig

func NewListenConfig(namespace, name string, obj ListenConfig) *ListenConfig

func (*ListenConfig) DeepCopy

func (in *ListenConfig) DeepCopy() *ListenConfig

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

func (*ListenConfig) DeepCopyInto

func (in *ListenConfig) DeepCopyInto(out *ListenConfig)

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

func (*ListenConfig) DeepCopyObject

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

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

type ListenConfigChangeHandlerFunc

type ListenConfigChangeHandlerFunc func(obj *ListenConfig) (runtime.Object, error)

type ListenConfigClient

type ListenConfigClient interface {
	Create(*ListenConfig) (*ListenConfig, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ListenConfig, error)
	Update(*ListenConfig) (*ListenConfig, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ListenConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ListenConfigClientCache

	OnCreate(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ListenConfigInterface
}

type ListenConfigClientCache

type ListenConfigClientCache interface {
	Get(namespace, name string) (*ListenConfig, error)
	List(namespace string, selector labels.Selector) ([]*ListenConfig, error)

	Index(name string, indexer ListenConfigIndexer)
	GetIndexed(name, key string) ([]*ListenConfig, error)
}

type ListenConfigController

type ListenConfigController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ListenConfigLister
	AddHandler(ctx context.Context, name string, handler ListenConfigHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ListenConfigHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ListenConfigHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ListenConfigHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ListenConfigHandlerFunc

type ListenConfigHandlerFunc func(key string, obj *ListenConfig) (runtime.Object, error)

func NewListenConfigLifecycleAdapter

func NewListenConfigLifecycleAdapter(name string, clusterScoped bool, client ListenConfigInterface, l ListenConfigLifecycle) ListenConfigHandlerFunc

type ListenConfigIndexer

type ListenConfigIndexer func(obj *ListenConfig) ([]string, error)

type ListenConfigInterface

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

type ListenConfigLifecycle

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

type ListenConfigList

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

func (*ListenConfigList) DeepCopy

func (in *ListenConfigList) DeepCopy() *ListenConfigList

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

func (*ListenConfigList) DeepCopyInto

func (in *ListenConfigList) DeepCopyInto(out *ListenConfigList)

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

func (*ListenConfigList) DeepCopyObject

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

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

type ListenConfigLister

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

type ListenConfigsGetter

type ListenConfigsGetter interface {
	ListenConfigs(namespace string) ListenConfigInterface
}

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

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

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

func (*LoadBalancerOpenstackOpts) DeepCopyInto

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

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"`
}

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 LoggingSystemImages

type LoggingSystemImages struct {
	Fluentd                       string `json:"fluentd,omitempty"`
	FluentdHelper                 string `json:"fluentdHelper,omitempty"`
	Elaticsearch                  string `json:"elaticsearch,omitempty"`
	Kibana                        string `json:"kibana,omitempty"`
	Busybox                       string `json:"busybox,omitempty"`
	LogAggregatorFlexVolumeDriver string `json:"logAggregatorFlexVolumeDriver,omitempty"`
}

func (*LoggingSystemImages) DeepCopy

func (in *LoggingSystemImages) DeepCopy() *LoggingSystemImages

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

func (*LoggingSystemImages) DeepCopyInto

func (in *LoggingSystemImages) DeepCopyInto(out *LoggingSystemImages)

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 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

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 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  `` /* 138-byte string literal not displayed */
	ThresholdValue float64 `json:"thresholdValue,omitempty" norman:"required,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 MonitorMetricClient

type MonitorMetricClient interface {
	Create(*MonitorMetric) (*MonitorMetric, error)
	Get(namespace, name string, opts metav1.GetOptions) (*MonitorMetric, error)
	Update(*MonitorMetric) (*MonitorMetric, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*MonitorMetricList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() MonitorMetricClientCache

	OnCreate(ctx context.Context, name string, sync MonitorMetricChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync MonitorMetricChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync MonitorMetricChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() MonitorMetricInterface
}

type MonitorMetricClientCache

type MonitorMetricClientCache interface {
	Get(namespace, name string) (*MonitorMetric, error)
	List(namespace string, selector labels.Selector) ([]*MonitorMetric, error)

	Index(name string, indexer MonitorMetricIndexer)
	GetIndexed(name, key string) ([]*MonitorMetric, 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)
	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 MonitorMetricIndexer

type MonitorMetricIndexer func(obj *MonitorMetric) ([]string, error)

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)
	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"`
}

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 {
	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 {
	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 MultiClusterAppClient

type MultiClusterAppClient interface {
	Create(*MultiClusterApp) (*MultiClusterApp, error)
	Get(namespace, name string, opts metav1.GetOptions) (*MultiClusterApp, error)
	Update(*MultiClusterApp) (*MultiClusterApp, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*MultiClusterAppList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() MultiClusterAppClientCache

	OnCreate(ctx context.Context, name string, sync MultiClusterAppChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync MultiClusterAppChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync MultiClusterAppChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() MultiClusterAppInterface
}

type MultiClusterAppClientCache

type MultiClusterAppClientCache interface {
	Get(namespace, name string) (*MultiClusterApp, error)
	List(namespace string, selector labels.Selector) ([]*MultiClusterApp, error)

	Index(name string, indexer MultiClusterAppIndexer)
	GetIndexed(name, key string) ([]*MultiClusterApp, 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)
	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 MultiClusterAppIndexer

type MultiClusterAppIndexer func(obj *MultiClusterApp) ([]string, error)

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)
	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

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 MultiClusterAppRevisionClientCache

type MultiClusterAppRevisionClientCache interface {
	Get(namespace, name string) (*MultiClusterAppRevision, error)
	List(namespace string, selector labels.Selector) ([]*MultiClusterAppRevision, error)

	Index(name string, indexer MultiClusterAppRevisionIndexer)
	GetIndexed(name, key string) ([]*MultiClusterAppRevision, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type MultiClusterAppRevisionHandlerFunc

type MultiClusterAppRevisionHandlerFunc func(key string, obj *MultiClusterAppRevision) (runtime.Object, error)

type MultiClusterAppRevisionIndexer

type MultiClusterAppRevisionIndexer func(obj *MultiClusterAppRevision) ([]string, error)

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)
	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

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

func (*MultiClusterAppRevisionList) DeepCopyInto

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

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

func (*MultiClusterAppRollbackInput) DeepCopyInto

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"`
	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"`
}

func (*MultiClusterAppStatus) DeepCopy

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

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"`
	// 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"`
}

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.

type NodeChangeHandlerFunc

type NodeChangeHandlerFunc func(obj *Node) (runtime.Object, error)

type NodeClient

type NodeClient interface {
	Create(*Node) (*Node, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Node, error)
	Update(*Node) (*Node, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*NodeList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() NodeClientCache

	OnCreate(ctx context.Context, name string, sync NodeChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync NodeChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync NodeChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() NodeInterface
}

type NodeClientCache

type NodeClientCache interface {
	Get(namespace, name string) (*Node, error)
	List(namespace string, selector labels.Selector) ([]*Node, error)

	Index(name string, indexer NodeIndexer)
	GetIndexed(name, key string) ([]*Node, 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)
	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 `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 `json:"ignoreDaemonSets,omitempty" norman:"default=true"`
	// Continue even if there are pods using emptyDir
	DeleteLocalData bool `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 `json:"gracePeriod,omitempty" norman:"default=-1"`
	// Time to wait (in seconds) before giving up for one try
	Timeout int `json:"timeout" norman:"min=1,max=10800,default=60"`
}

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 NodeDriverClient

type NodeDriverClient interface {
	Create(*NodeDriver) (*NodeDriver, error)
	Get(namespace, name string, opts metav1.GetOptions) (*NodeDriver, error)
	Update(*NodeDriver) (*NodeDriver, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*NodeDriverList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() NodeDriverClientCache

	OnCreate(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() NodeDriverInterface
}

type NodeDriverClientCache

type NodeDriverClientCache interface {
	Get(namespace, name string) (*NodeDriver, error)
	List(namespace string, selector labels.Selector) ([]*NodeDriver, error)

	Index(name string, indexer NodeDriverIndexer)
	GetIndexed(name, key string) ([]*NodeDriver, 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)
	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 NodeDriverIndexer

type NodeDriverIndexer func(obj *NodeDriver) ([]string, error)

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)
	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 NodeIndexer

type NodeIndexer func(obj *Node) ([]string, error)

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)
	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 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.

type NodePoolChangeHandlerFunc

type NodePoolChangeHandlerFunc func(obj *NodePool) (runtime.Object, error)

type NodePoolClient

type NodePoolClient interface {
	Create(*NodePool) (*NodePool, error)
	Get(namespace, name string, opts metav1.GetOptions) (*NodePool, error)
	Update(*NodePool) (*NodePool, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*NodePoolList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() NodePoolClientCache

	OnCreate(ctx context.Context, name string, sync NodePoolChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync NodePoolChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync NodePoolChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() NodePoolInterface
}

type NodePoolClientCache

type NodePoolClientCache interface {
	Get(namespace, name string) (*NodePool, error)
	List(namespace string, selector labels.Selector) ([]*NodePool, error)

	Index(name string, indexer NodePoolIndexer)
	GetIndexed(name, key string) ([]*NodePool, 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)
	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 NodePoolIndexer

type NodePoolIndexer func(obj *NodePool) ([]string, error)

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)
	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"`

	DisplayName string `json:"displayName"`
	ClusterName string `json:"clusterName,omitempty" norman:"type=reference[cluster],noupdate,required"`

	DeleteNotReadyAfterSecs time.Duration `json:"deleteNotReadyAfterSecs" norman:"default=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.

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"`
	DesiredNodeLabels        map[string]string `json:"desiredNodeLabels,omitempty"`
	DesiredNodeAnnotations   map[string]string `json:"desiredNodeAnnotations,omitempty"`
	CurrentNodeLabels        map[string]string `json:"currentNodeLabels,omitempty"`
	CurrentNodeAnnotations   map[string]string `json:"currentNodeAnnotations,omitempty"`
	DesiredNodeUnschedulable string            `json:"desiredNodeUnschedulable,omitempty"`
	NodeDrainInput           *NodeDrainInput   `json:"nodeDrainInput,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"`
}

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 NodeTemplateClient

type NodeTemplateClient interface {
	Create(*NodeTemplate) (*NodeTemplate, error)
	Get(namespace, name string, opts metav1.GetOptions) (*NodeTemplate, error)
	Update(*NodeTemplate) (*NodeTemplate, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*NodeTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() NodeTemplateClientCache

	OnCreate(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() NodeTemplateInterface
}

type NodeTemplateClientCache

type NodeTemplateClientCache interface {
	Get(namespace, name string) (*NodeTemplate, error)
	List(namespace string, selector labels.Selector) ([]*NodeTemplate, error)

	Index(name string, indexer NodeTemplateIndexer)
	GetIndexed(name, key string) ([]*NodeTemplate, 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

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)
	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 NodeTemplateIndexer

type NodeTemplateIndexer func(obj *NodeTemplate) ([]string, error)

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)
	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]"`
	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 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"`
}

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.

type NotifierChangeHandlerFunc

type NotifierChangeHandlerFunc func(obj *Notifier) (runtime.Object, error)

type NotifierClient

type NotifierClient interface {
	Create(*Notifier) (*Notifier, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Notifier, error)
	Update(*Notifier) (*Notifier, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*NotifierList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() NotifierClientCache

	OnCreate(ctx context.Context, name string, sync NotifierChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync NotifierChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync NotifierChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() NotifierInterface
}

type NotifierClientCache

type NotifierClientCache interface {
	Get(namespace, name string) (*Notifier, error)
	List(namespace string, selector labels.Selector) ([]*Notifier, error)

	Index(name string, indexer NotifierIndexer)
	GetIndexed(name, key string) ([]*Notifier, 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)
	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 NotifierIndexer

type NotifierIndexer func(obj *Notifier) ([]string, error)

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)
	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"`
	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"`
}

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.

type NotifierStatus

type NotifierStatus struct {
}

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

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

func (*OpenLdapTestAndApplyInput) DeepCopyInto

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

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        extv1.PodSecurityPolicySpec `json:"spec,omitempty"`
}

func NewPodSecurityPolicyTemplate

func NewPodSecurityPolicyTemplate(namespace, name string, obj PodSecurityPolicyTemplate) *PodSecurityPolicyTemplate

func (*PodSecurityPolicyTemplate) DeepCopy

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

func (*PodSecurityPolicyTemplate) DeepCopyInto

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 PodSecurityPolicyTemplateClientCache

type PodSecurityPolicyTemplateClientCache interface {
	Get(namespace, name string) (*PodSecurityPolicyTemplate, error)
	List(namespace string, selector labels.Selector) ([]*PodSecurityPolicyTemplate, error)

	Index(name string, indexer PodSecurityPolicyTemplateIndexer)
	GetIndexed(name, key string) ([]*PodSecurityPolicyTemplate, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type PodSecurityPolicyTemplateHandlerFunc

type PodSecurityPolicyTemplateHandlerFunc func(key string, obj *PodSecurityPolicyTemplate) (runtime.Object, error)

type PodSecurityPolicyTemplateIndexer

type PodSecurityPolicyTemplateIndexer func(obj *PodSecurityPolicyTemplate) ([]string, error)

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)
	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

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

func (*PodSecurityPolicyTemplateList) DeepCopyInto

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 (*PodSecurityPolicyTemplateProjectBinding) DeepCopy

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

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopyInto

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

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopyObject

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 PodSecurityPolicyTemplateProjectBindingClientCache

type PodSecurityPolicyTemplateProjectBindingClientCache interface {
	Get(namespace, name string) (*PodSecurityPolicyTemplateProjectBinding, error)
	List(namespace string, selector labels.Selector) ([]*PodSecurityPolicyTemplateProjectBinding, error)

	Index(name string, indexer PodSecurityPolicyTemplateProjectBindingIndexer)
	GetIndexed(name, key string) ([]*PodSecurityPolicyTemplateProjectBinding, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type PodSecurityPolicyTemplateProjectBindingIndexer

type PodSecurityPolicyTemplateProjectBindingIndexer func(obj *PodSecurityPolicyTemplateProjectBinding) ([]string, error)

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)
	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 PodSecurityPolicyTemplateProjectBindingList

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

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopy

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

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopyInto

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

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopyObject

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 PreferenceClient

type PreferenceClient interface {
	Create(*Preference) (*Preference, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Preference, error)
	Update(*Preference) (*Preference, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*PreferenceList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() PreferenceClientCache

	OnCreate(ctx context.Context, name string, sync PreferenceChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync PreferenceChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync PreferenceChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() PreferenceInterface
}

type PreferenceClientCache

type PreferenceClientCache interface {
	Get(namespace, name string) (*Preference, error)
	List(namespace string, selector labels.Selector) ([]*Preference, error)

	Index(name string, indexer PreferenceIndexer)
	GetIndexed(name, key string) ([]*Preference, 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)
	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 PreferenceIndexer

type PreferenceIndexer func(obj *Preference) ([]string, error)

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)
	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 PrincipalClient

type PrincipalClient interface {
	Create(*Principal) (*Principal, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Principal, error)
	Update(*Principal) (*Principal, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*PrincipalList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() PrincipalClientCache

	OnCreate(ctx context.Context, name string, sync PrincipalChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync PrincipalChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync PrincipalChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() PrincipalInterface
}

type PrincipalClientCache

type PrincipalClientCache interface {
	Get(namespace, name string) (*Principal, error)
	List(namespace string, selector labels.Selector) ([]*Principal, error)

	Index(name string, indexer PrincipalIndexer)
	GetIndexed(name, key string) ([]*Principal, 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)
	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 PrincipalIndexer

type PrincipalIndexer func(obj *Principal) ([]string, error)

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)
	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"`
}

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.

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.

type ProjectAlertChangeHandlerFunc

type ProjectAlertChangeHandlerFunc func(obj *ProjectAlert) (runtime.Object, error)

type ProjectAlertClient

type ProjectAlertClient interface {
	Create(*ProjectAlert) (*ProjectAlert, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ProjectAlert, error)
	Update(*ProjectAlert) (*ProjectAlert, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ProjectAlertList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ProjectAlertClientCache

	OnCreate(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ProjectAlertInterface
}

type ProjectAlertClientCache

type ProjectAlertClientCache interface {
	Get(namespace, name string) (*ProjectAlert, error)
	List(namespace string, selector labels.Selector) ([]*ProjectAlert, error)

	Index(name string, indexer ProjectAlertIndexer)
	GetIndexed(name, key string) ([]*ProjectAlert, 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)
	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.

type ProjectAlertGroupChangeHandlerFunc

type ProjectAlertGroupChangeHandlerFunc func(obj *ProjectAlertGroup) (runtime.Object, error)

type ProjectAlertGroupClient

type ProjectAlertGroupClient interface {
	Create(*ProjectAlertGroup) (*ProjectAlertGroup, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ProjectAlertGroup, error)
	Update(*ProjectAlertGroup) (*ProjectAlertGroup, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ProjectAlertGroupList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ProjectAlertGroupClientCache

	OnCreate(ctx context.Context, name string, sync ProjectAlertGroupChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ProjectAlertGroupChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ProjectAlertGroupChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ProjectAlertGroupInterface
}

type ProjectAlertGroupClientCache

type ProjectAlertGroupClientCache interface {
	Get(namespace, name string) (*ProjectAlertGroup, error)
	List(namespace string, selector labels.Selector) ([]*ProjectAlertGroup, error)

	Index(name string, indexer ProjectAlertGroupIndexer)
	GetIndexed(name, key string) ([]*ProjectAlertGroup, 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)
	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 ProjectAlertGroupIndexer

type ProjectAlertGroupIndexer func(obj *ProjectAlertGroup) ([]string, error)

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)
	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

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 ProjectAlertIndexer

type ProjectAlertIndexer func(obj *ProjectAlert) ([]string, error)

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)
	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.

type ProjectAlertRuleChangeHandlerFunc

type ProjectAlertRuleChangeHandlerFunc func(obj *ProjectAlertRule) (runtime.Object, error)

type ProjectAlertRuleClient

type ProjectAlertRuleClient interface {
	Create(*ProjectAlertRule) (*ProjectAlertRule, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ProjectAlertRule, error)
	Update(*ProjectAlertRule) (*ProjectAlertRule, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ProjectAlertRuleList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ProjectAlertRuleClientCache

	OnCreate(ctx context.Context, name string, sync ProjectAlertRuleChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ProjectAlertRuleChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ProjectAlertRuleChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ProjectAlertRuleInterface
}

type ProjectAlertRuleClientCache

type ProjectAlertRuleClientCache interface {
	Get(namespace, name string) (*ProjectAlertRule, error)
	List(namespace string, selector labels.Selector) ([]*ProjectAlertRule, error)

	Index(name string, indexer ProjectAlertRuleIndexer)
	GetIndexed(name, key string) ([]*ProjectAlertRule, 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)
	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 ProjectAlertRuleIndexer

type ProjectAlertRuleIndexer func(obj *ProjectAlertRule) ([]string, error)

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)
	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

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

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.

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.

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.

type ProjectCatalogChangeHandlerFunc

type ProjectCatalogChangeHandlerFunc func(obj *ProjectCatalog) (runtime.Object, error)

type ProjectCatalogClient

type ProjectCatalogClient interface {
	Create(*ProjectCatalog) (*ProjectCatalog, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ProjectCatalog, error)
	Update(*ProjectCatalog) (*ProjectCatalog, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ProjectCatalogList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ProjectCatalogClientCache

	OnCreate(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ProjectCatalogInterface
}

type ProjectCatalogClientCache

type ProjectCatalogClientCache interface {
	Get(namespace, name string) (*ProjectCatalog, error)
	List(namespace string, selector labels.Selector) ([]*ProjectCatalog, error)

	Index(name string, indexer ProjectCatalogIndexer)
	GetIndexed(name, key string) ([]*ProjectCatalog, 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)
	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 ProjectCatalogIndexer

type ProjectCatalogIndexer func(obj *ProjectCatalog) ([]string, error)

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)
	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 ProjectClient

type ProjectClient interface {
	Create(*Project) (*Project, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Project, error)
	Update(*Project) (*Project, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ProjectList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ProjectClientCache

	OnCreate(ctx context.Context, name string, sync ProjectChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ProjectChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ProjectChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ProjectInterface
}

type ProjectClientCache

type ProjectClientCache interface {
	Get(namespace, name string) (*Project, error)
	List(namespace string, selector labels.Selector) ([]*Project, error)

	Index(name string, indexer ProjectIndexer)
	GetIndexed(name, key string) ([]*Project, 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)
	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.

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 ProjectIndexer

type ProjectIndexer func(obj *Project) ([]string, error)

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)
	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.

type ProjectLoggingChangeHandlerFunc

type ProjectLoggingChangeHandlerFunc func(obj *ProjectLogging) (runtime.Object, error)

type ProjectLoggingClient

type ProjectLoggingClient interface {
	Create(*ProjectLogging) (*ProjectLogging, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ProjectLogging, error)
	Update(*ProjectLogging) (*ProjectLogging, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ProjectLoggingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ProjectLoggingClientCache

	OnCreate(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ProjectLoggingInterface
}

type ProjectLoggingClientCache

type ProjectLoggingClientCache interface {
	Get(namespace, name string) (*ProjectLogging, error)
	List(namespace string, selector labels.Selector) ([]*ProjectLogging, error)

	Index(name string, indexer ProjectLoggingIndexer)
	GetIndexed(name, key string) ([]*ProjectLogging, 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)
	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 ProjectLoggingIndexer

type ProjectLoggingIndexer func(obj *ProjectLogging) ([]string, error)

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)
	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.

type ProjectLoggingStatus

type ProjectLoggingStatus struct {
	Conditions  []LoggingCondition `json:"conditions,omitempty"`
	AppliedSpec ProjectLoggingSpec `json:"appliedSpec,omitempty"`
}

func (*ProjectLoggingStatus) DeepCopy

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

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.

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.

type ProjectMonitorGraphChangeHandlerFunc

type ProjectMonitorGraphChangeHandlerFunc func(obj *ProjectMonitorGraph) (runtime.Object, error)

type ProjectMonitorGraphClient

type ProjectMonitorGraphClient interface {
	Create(*ProjectMonitorGraph) (*ProjectMonitorGraph, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ProjectMonitorGraph, error)
	Update(*ProjectMonitorGraph) (*ProjectMonitorGraph, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ProjectMonitorGraphList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ProjectMonitorGraphClientCache

	OnCreate(ctx context.Context, name string, sync ProjectMonitorGraphChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ProjectMonitorGraphChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ProjectMonitorGraphChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ProjectMonitorGraphInterface
}

type ProjectMonitorGraphClientCache

type ProjectMonitorGraphClientCache interface {
	Get(namespace, name string) (*ProjectMonitorGraph, error)
	List(namespace string, selector labels.Selector) ([]*ProjectMonitorGraph, error)

	Index(name string, indexer ProjectMonitorGraphIndexer)
	GetIndexed(name, key string) ([]*ProjectMonitorGraph, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectMonitorGraphHandlerFunc

type ProjectMonitorGraphHandlerFunc func(key string, obj *ProjectMonitorGraph) (runtime.Object, error)

type ProjectMonitorGraphIndexer

type ProjectMonitorGraphIndexer func(obj *ProjectMonitorGraph) ([]string, error)

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)
	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

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

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.

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

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 ProjectNetworkPolicyClientCache

type ProjectNetworkPolicyClientCache interface {
	Get(namespace, name string) (*ProjectNetworkPolicy, error)
	List(namespace string, selector labels.Selector) ([]*ProjectNetworkPolicy, error)

	Index(name string, indexer ProjectNetworkPolicyIndexer)
	GetIndexed(name, key string) ([]*ProjectNetworkPolicy, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectNetworkPolicyHandlerFunc

type ProjectNetworkPolicyHandlerFunc func(key string, obj *ProjectNetworkPolicy) (runtime.Object, error)

type ProjectNetworkPolicyIndexer

type ProjectNetworkPolicyIndexer func(obj *ProjectNetworkPolicy) ([]string, error)

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)
	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

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

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.

type ProjectNetworkPolicyStatus

type ProjectNetworkPolicyStatus struct {
}

func (*ProjectNetworkPolicyStatus) DeepCopy

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

func (*ProjectNetworkPolicyStatus) DeepCopyInto

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

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:"type=reference[user]"`
	UserPrincipalName  string `json:"userPrincipalName,omitempty" norman:"type=reference[principal]"`
	GroupName          string `json:"groupName,omitempty" norman:"type=reference[group]"`
	GroupPrincipalName string `json:"groupPrincipalName,omitempty" norman:"type=reference[principal]"`
	ProjectName        string `json:"projectName,omitempty" norman:"required,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

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

func (*ProjectRoleTemplateBinding) DeepCopyInto

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.

type ProjectRoleTemplateBindingChangeHandlerFunc

type ProjectRoleTemplateBindingChangeHandlerFunc func(obj *ProjectRoleTemplateBinding) (runtime.Object, error)

type ProjectRoleTemplateBindingClientCache

type ProjectRoleTemplateBindingClientCache interface {
	Get(namespace, name string) (*ProjectRoleTemplateBinding, error)
	List(namespace string, selector labels.Selector) ([]*ProjectRoleTemplateBinding, error)

	Index(name string, indexer ProjectRoleTemplateBindingIndexer)
	GetIndexed(name, key string) ([]*ProjectRoleTemplateBinding, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ProjectRoleTemplateBindingHandlerFunc

type ProjectRoleTemplateBindingHandlerFunc func(key string, obj *ProjectRoleTemplateBinding) (runtime.Object, error)

type ProjectRoleTemplateBindingIndexer

type ProjectRoleTemplateBindingIndexer func(obj *ProjectRoleTemplateBinding) ([]string, error)

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)
	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

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

func (*ProjectRoleTemplateBindingList) DeepCopyInto

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.

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.

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

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

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.

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

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

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.

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"`
}

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 RKEAddonClient

type RKEAddonClient interface {
	Create(*RKEAddon) (*RKEAddon, error)
	Get(namespace, name string, opts metav1.GetOptions) (*RKEAddon, error)
	Update(*RKEAddon) (*RKEAddon, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*RKEAddonList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() RKEAddonClientCache

	OnCreate(ctx context.Context, name string, sync RKEAddonChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync RKEAddonChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync RKEAddonChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() RKEAddonInterface
}

type RKEAddonClientCache

type RKEAddonClientCache interface {
	Get(namespace, name string) (*RKEAddon, error)
	List(namespace string, selector labels.Selector) ([]*RKEAddon, error)

	Index(name string, indexer RKEAddonIndexer)
	GetIndexed(name, key string) ([]*RKEAddon, 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)
	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 RKEAddonIndexer

type RKEAddonIndexer func(obj *RKEAddon) ([]string, error)

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)
	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"`
}

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"`
}

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 RKEK8sServiceOptionClient

type RKEK8sServiceOptionClient interface {
	Create(*RKEK8sServiceOption) (*RKEK8sServiceOption, error)
	Get(namespace, name string, opts metav1.GetOptions) (*RKEK8sServiceOption, error)
	Update(*RKEK8sServiceOption) (*RKEK8sServiceOption, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*RKEK8sServiceOptionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() RKEK8sServiceOptionClientCache

	OnCreate(ctx context.Context, name string, sync RKEK8sServiceOptionChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync RKEK8sServiceOptionChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync RKEK8sServiceOptionChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() RKEK8sServiceOptionInterface
}

type RKEK8sServiceOptionClientCache

type RKEK8sServiceOptionClientCache interface {
	Get(namespace, name string) (*RKEK8sServiceOption, error)
	List(namespace string, selector labels.Selector) ([]*RKEK8sServiceOption, error)

	Index(name string, indexer RKEK8sServiceOptionIndexer)
	GetIndexed(name, key string) ([]*RKEK8sServiceOption, 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)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type RKEK8sServiceOptionHandlerFunc

type RKEK8sServiceOptionHandlerFunc func(key string, obj *RKEK8sServiceOption) (runtime.Object, error)

type RKEK8sServiceOptionIndexer

type RKEK8sServiceOptionIndexer func(obj *RKEK8sServiceOption) ([]string, error)

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)
	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

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 RKEK8sSystemImageClient

type RKEK8sSystemImageClient interface {
	Create(*RKEK8sSystemImage) (*RKEK8sSystemImage, error)
	Get(namespace, name string, opts metav1.GetOptions) (*RKEK8sSystemImage, error)
	Update(*RKEK8sSystemImage) (*RKEK8sSystemImage, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*RKEK8sSystemImageList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() RKEK8sSystemImageClientCache

	OnCreate(ctx context.Context, name string, sync RKEK8sSystemImageChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync RKEK8sSystemImageChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync RKEK8sSystemImageChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() RKEK8sSystemImageInterface
}

type RKEK8sSystemImageClientCache

type RKEK8sSystemImageClientCache interface {
	Get(namespace, name string) (*RKEK8sSystemImage, error)
	List(namespace string, selector labels.Selector) ([]*RKEK8sSystemImage, error)

	Index(name string, indexer RKEK8sSystemImageIndexer)
	GetIndexed(name, key string) ([]*RKEK8sSystemImage, 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)
	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 RKEK8sSystemImageIndexer

type RKEK8sSystemImageIndexer func(obj *RKEK8sSystemImage) ([]string, error)

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)
	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

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 RKEK8sWindowsSystemImage

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

	SystemImages WindowsSystemImages `yaml:"windows_system_images" json:"windowsSystemImages,omitempty"`
}

func NewRKEK8sWindowsSystemImage

func NewRKEK8sWindowsSystemImage(namespace, name string, obj RKEK8sWindowsSystemImage) *RKEK8sWindowsSystemImage

func (*RKEK8sWindowsSystemImage) DeepCopy

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

func (*RKEK8sWindowsSystemImage) DeepCopyInto

func (in *RKEK8sWindowsSystemImage) DeepCopyInto(out *RKEK8sWindowsSystemImage)

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

func (*RKEK8sWindowsSystemImage) DeepCopyObject

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

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

type RKEK8sWindowsSystemImageChangeHandlerFunc

type RKEK8sWindowsSystemImageChangeHandlerFunc func(obj *RKEK8sWindowsSystemImage) (runtime.Object, error)

type RKEK8sWindowsSystemImageClientCache

type RKEK8sWindowsSystemImageClientCache interface {
	Get(namespace, name string) (*RKEK8sWindowsSystemImage, error)
	List(namespace string, selector labels.Selector) ([]*RKEK8sWindowsSystemImage, error)

	Index(name string, indexer RKEK8sWindowsSystemImageIndexer)
	GetIndexed(name, key string) ([]*RKEK8sWindowsSystemImage, error)
}

type RKEK8sWindowsSystemImageController

type RKEK8sWindowsSystemImageController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() RKEK8sWindowsSystemImageLister
	AddHandler(ctx context.Context, name string, handler RKEK8sWindowsSystemImageHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sWindowsSystemImageHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RKEK8sWindowsSystemImageHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler RKEK8sWindowsSystemImageHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type RKEK8sWindowsSystemImageHandlerFunc

type RKEK8sWindowsSystemImageHandlerFunc func(key string, obj *RKEK8sWindowsSystemImage) (runtime.Object, error)

type RKEK8sWindowsSystemImageIndexer

type RKEK8sWindowsSystemImageIndexer func(obj *RKEK8sWindowsSystemImage) ([]string, error)

type RKEK8sWindowsSystemImageInterface

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

type RKEK8sWindowsSystemImageLifecycle

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

type RKEK8sWindowsSystemImageList

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

func (*RKEK8sWindowsSystemImageList) DeepCopy

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

func (*RKEK8sWindowsSystemImageList) DeepCopyInto

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

func (*RKEK8sWindowsSystemImageList) DeepCopyObject

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

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

type RKEK8sWindowsSystemImageLister

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

type RKEK8sWindowsSystemImagesGetter

type RKEK8sWindowsSystemImagesGetter interface {
	RKEK8sWindowsSystemImages(namespace string) RKEK8sWindowsSystemImageInterface
}

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"`
	// 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"`
	// 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"`
	// 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"`
}

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 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"`
	// 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"`
}

func (*RancherKubernetesEngineConfig) DeepCopy

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

func (*RancherKubernetesEngineConfig) DeepCopyInto

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

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"`
}

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]"`
}

func (*RestoreFromEtcdBackupInput) DeepCopy

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

func (*RestoreFromEtcdBackupInput) DeepCopyInto

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 RoleTemplateClient

type RoleTemplateClient interface {
	Create(*RoleTemplate) (*RoleTemplate, error)
	Get(namespace, name string, opts metav1.GetOptions) (*RoleTemplate, error)
	Update(*RoleTemplate) (*RoleTemplate, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*RoleTemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() RoleTemplateClientCache

	OnCreate(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() RoleTemplateInterface
}

type RoleTemplateClientCache

type RoleTemplateClientCache interface {
	Get(namespace, name string) (*RoleTemplate, error)
	List(namespace string, selector labels.Selector) ([]*RoleTemplate, error)

	Index(name string, indexer RoleTemplateIndexer)
	GetIndexed(name, key string) ([]*RoleTemplate, 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)
	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 RoleTemplateIndexer

type RoleTemplateIndexer func(obj *RoleTemplate) ([]string, error)

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)
	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

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

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"`
}

func (*Route53ProviderConfig) DeepCopy

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:"required,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"`
}

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"`
	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

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 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

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 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

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

func (*SetPodSecurityPolicyTemplateInput) DeepCopyInto

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 SettingClient

type SettingClient interface {
	Create(*Setting) (*Setting, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Setting, error)
	Update(*Setting) (*Setting, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*SettingList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() SettingClientCache

	OnCreate(ctx context.Context, name string, sync SettingChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync SettingChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync SettingChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() SettingInterface
}

type SettingClientCache

type SettingClientCache interface {
	Get(namespace, name string) (*Setting, error)
	List(namespace string, selector labels.Selector) ([]*Setting, error)

	Index(name string, indexer SettingIndexer)
	GetIndexed(name, key string) ([]*Setting, 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)
	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 SettingIndexer

type SettingIndexer func(obj *Setting) ([]string, error)

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)
	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 SlackConfig

type SlackConfig struct {
	DefaultRecipient string `json:"defaultRecipient,omitempty" norman:"required"`
	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"`
}

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.

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 TemplateClient

type TemplateClient interface {
	Create(*Template) (*Template, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Template, error)
	Update(*Template) (*Template, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*TemplateList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() TemplateClientCache

	OnCreate(ctx context.Context, name string, sync TemplateChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync TemplateChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync TemplateChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() TemplateInterface
}

type TemplateClientCache

type TemplateClientCache interface {
	Get(namespace, name string) (*Template, error)
	List(namespace string, selector labels.Selector) ([]*Template, error)

	Index(name string, indexer TemplateIndexer)
	GetIndexed(name, key string) ([]*Template, 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 TemplateContentClient

type TemplateContentClient interface {
	Create(*TemplateContent) (*TemplateContent, error)
	Get(namespace, name string, opts metav1.GetOptions) (*TemplateContent, error)
	Update(*TemplateContent) (*TemplateContent, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*TemplateContentList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() TemplateContentClientCache

	OnCreate(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() TemplateContentInterface
}

type TemplateContentClientCache

type TemplateContentClientCache interface {
	Get(namespace, name string) (*TemplateContent, error)
	List(namespace string, selector labels.Selector) ([]*TemplateContent, error)

	Index(name string, indexer TemplateContentIndexer)
	GetIndexed(name, key string) ([]*TemplateContent, 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)
	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 TemplateContentIndexer

type TemplateContentIndexer func(obj *TemplateContent) ([]string, error)

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)
	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)
	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 TemplateIndexer

type TemplateIndexer func(obj *Template) ([]string, error)

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)
	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 {
}

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 TemplateVersionClient

type TemplateVersionClient interface {
	Create(*TemplateVersion) (*TemplateVersion, error)
	Get(namespace, name string, opts metav1.GetOptions) (*TemplateVersion, error)
	Update(*TemplateVersion) (*TemplateVersion, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*TemplateVersionList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() TemplateVersionClientCache

	OnCreate(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() TemplateVersionInterface
}

type TemplateVersionClientCache

type TemplateVersionClientCache interface {
	Get(namespace, name string) (*TemplateVersion, error)
	List(namespace string, selector labels.Selector) ([]*TemplateVersion, error)

	Index(name string, indexer TemplateVersionIndexer)
	GetIndexed(name, key string) ([]*TemplateVersion, 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)
	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 TemplateVersionIndexer

type TemplateVersionIndexer func(obj *TemplateVersion) ([]string, error)

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)
	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 {
}

func (*TemplateVersionStatus) DeepCopy

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.

type TokenChangeHandlerFunc

type TokenChangeHandlerFunc func(obj *Token) (runtime.Object, error)

type TokenClient

type TokenClient interface {
	Create(*Token) (*Token, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Token, error)
	Update(*Token) (*Token, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*TokenList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() TokenClientCache

	OnCreate(ctx context.Context, name string, sync TokenChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync TokenChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync TokenChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() TokenInterface
}

type TokenClientCache

type TokenClientCache interface {
	Get(namespace, name string) (*Token, error)
	List(namespace string, selector labels.Selector) ([]*Token, error)

	Index(name string, indexer TokenIndexer)
	GetIndexed(name, key string) ([]*Token, 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)
	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 TokenIndexer

type TokenIndexer func(obj *Token) ([]string, error)

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)
	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

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

func (*UpdateGlobalDNSTargetsInput) DeepCopyInto

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

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

func (*UpdateMultiClusterAppTargetsInput) DeepCopyInto

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"`
	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 UserAttributeClient

type UserAttributeClient interface {
	Create(*UserAttribute) (*UserAttribute, error)
	Get(namespace, name string, opts metav1.GetOptions) (*UserAttribute, error)
	Update(*UserAttribute) (*UserAttribute, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*UserAttributeList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() UserAttributeClientCache

	OnCreate(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() UserAttributeInterface
}

type UserAttributeClientCache

type UserAttributeClientCache interface {
	Get(namespace, name string) (*UserAttribute, error)
	List(namespace string, selector labels.Selector) ([]*UserAttribute, error)

	Index(name string, indexer UserAttributeIndexer)
	GetIndexed(name, key string) ([]*UserAttribute, 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)
	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 UserAttributeIndexer

type UserAttributeIndexer func(obj *UserAttribute) ([]string, error)

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)
	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 UserClient

type UserClient interface {
	Create(*User) (*User, error)
	Get(namespace, name string, opts metav1.GetOptions) (*User, error)
	Update(*User) (*User, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*UserList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() UserClientCache

	OnCreate(ctx context.Context, name string, sync UserChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync UserChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync UserChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() UserInterface
}

type UserClientCache

type UserClientCache interface {
	Get(namespace, name string) (*User, error)
	List(namespace string, selector labels.Selector) ([]*User, error)

	Index(name string, indexer UserIndexer)
	GetIndexed(name, key string) ([]*User, 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)
	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 UserIndexer

type UserIndexer func(obj *User) ([]string, error)

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)
	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

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

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"`
	*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

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

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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