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 

func (in *ActiveDirectoryConfig) DeepCopy() *ActiveDirectoryConfig

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

func (*ActiveDirectoryConfig) DeepCopyInto 

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

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

func (*ActiveDirectoryConfig) DeepCopyObject 

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

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

type ActiveDirectoryTestAndApplyInput 

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

func (*ActiveDirectoryTestAndApplyInput) DeepCopy 

func (in *ActiveDirectoryTestAndApplyInput) DeepCopy() *ActiveDirectoryTestAndApplyInput

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

func (*ActiveDirectoryTestAndApplyInput) DeepCopyInto 

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

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

type AlertCommonSpec 

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

func (*AlertCommonSpec) DeepCopy 

func (in *AlertCommonSpec) DeepCopy() *AlertCommonSpec

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

func (*AlertCommonSpec) DeepCopyInto 

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

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

type AlertStatus 

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

func (*AlertStatus) DeepCopy 

func (in *AlertStatus) DeepCopy() *AlertStatus

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

func (*AlertStatus) DeepCopyInto 

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

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

type 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 

func (in *AlidnsProviderConfig) DeepCopy() *AlidnsProviderConfig

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

func (*AlidnsProviderConfig) DeepCopyInto 

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

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

type Answer 

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

func (*Answer) DeepCopy 

func (in *Answer) DeepCopy() *Answer

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

func (*Answer) DeepCopyInto 

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

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

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 

func (in *AzureADConfigApplyInput) DeepCopy() *AzureADConfigApplyInput

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

func (*AzureADConfigApplyInput) DeepCopyInto 

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

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

type AzureADConfigTestOutput 

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

func (*AzureADConfigTestOutput) DeepCopy 

func (in *AzureADConfigTestOutput) DeepCopy() *AzureADConfigTestOutput

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

func (*AzureADConfigTestOutput) DeepCopyInto 

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

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

type AzureCloudProvider 

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

AzureCloudProvider options

func (*AzureCloudProvider) DeepCopy 

func (in *AzureCloudProvider) DeepCopy() *AzureCloudProvider

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

func (*AzureCloudProvider) DeepCopyInto 

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

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

type BackupConfig 

type BackupConfig struct {
	// Enable or disable recurring backups in rancher
	Enabled *bool `yaml:"enabled" json:"enabled,omitempty" norman:"default=true"`
	// Backup interval in hours
	IntervalHours int `yaml:"interval_hours" json:"intervalHours,omitempty" norman:"default=12"`
	// Number of backups to keep
	Retention int `yaml:"retention" json:"retention,omitempty" norman:"default=6"`
	// s3 target
	S3BackupConfig *S3BackupConfig `yaml:",omitempty" json:"s3BackupConfig"`
}

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 

func (in *BlockStorageOpenstackOpts) DeepCopy() *BlockStorageOpenstackOpts

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

func (*BlockStorageOpenstackOpts) DeepCopyInto 

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

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

type CalicoNetworkProvider 

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

func (*CalicoNetworkProvider) DeepCopy 

func (in *CalicoNetworkProvider) DeepCopy() *CalicoNetworkProvider

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

func (*CalicoNetworkProvider) DeepCopyInto 

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

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

type CanalNetworkProvider 

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

func (*CanalNetworkProvider) DeepCopy 

func (in *CanalNetworkProvider) DeepCopy() *CanalNetworkProvider

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

func (*CanalNetworkProvider) DeepCopyInto 

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

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

type Capabilities 

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

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 

func (in *CatalogTemplateVersion) DeepCopy() *CatalogTemplateVersion

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

func (*CatalogTemplateVersion) DeepCopyInto 

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

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

func (*CatalogTemplateVersion) DeepCopyObject 

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

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

type CatalogTemplateVersionChangeHandlerFunc 

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

type CatalogTemplateVersionClient 

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

	Cache() CatalogTemplateVersionClientCache

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

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

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)

func NewCatalogTemplateVersionLifecycleAdapter 

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

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 

func (in *CatalogTemplateVersionList) DeepCopy() *CatalogTemplateVersionList

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

func (*CatalogTemplateVersionList) DeepCopyInto 

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

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

func (*CatalogTemplateVersionList) DeepCopyObject 

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

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

type CatalogTemplateVersionLister 

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

type CatalogTemplateVersionsGetter 

type CatalogTemplateVersionsGetter interface {
	CatalogTemplateVersions(namespace string) CatalogTemplateVersionInterface
}

type CatalogTemplatesGetter 

type CatalogTemplatesGetter interface {
	CatalogTemplates(namespace string) CatalogTemplateInterface
}

type CatalogsGetter 

type CatalogsGetter interface {
	Catalogs(namespace string) CatalogInterface
}

type CertExpiration 

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

func (*CertExpiration) DeepCopy 

func (in *CertExpiration) DeepCopy() *CertExpiration

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

func (*CertExpiration) DeepCopyInto 

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

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

type ChangePasswordInput 

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

func (*ChangePasswordInput) DeepCopy 

func (in *ChangePasswordInput) DeepCopy() *ChangePasswordInput

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

func (*ChangePasswordInput) DeepCopyInto 

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

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

type 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 

func (in *CloudflareProviderConfig) DeepCopy() *CloudflareProviderConfig

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

func (*CloudflareProviderConfig) DeepCopyInto 

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

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

type Cluster 

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

func NewCluster 

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

func (*Cluster) DeepCopy 

func (in *Cluster) DeepCopy() *Cluster

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

func (*Cluster) DeepCopyInto 

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

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

func (*Cluster) DeepCopyObject 

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

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

type ClusterAlert 

type ClusterAlert struct {
	types.Namespaced

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

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

func NewClusterAlert 

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

func (*ClusterAlert) DeepCopy 

func (in *ClusterAlert) DeepCopy() *ClusterAlert

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

func (*ClusterAlert) DeepCopyInto 

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

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

func (*ClusterAlert) DeepCopyObject 

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

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

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 

func (in *ClusterAlertGroupList) DeepCopy() *ClusterAlertGroupList

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

func (*ClusterAlertGroupList) DeepCopyInto 

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

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

func (*ClusterAlertGroupList) DeepCopyObject 

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

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

type ClusterAlertGroupLister 

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

type ClusterAlertGroupsGetter 

type ClusterAlertGroupsGetter interface {
	ClusterAlertGroups(namespace string) ClusterAlertGroupInterface
}

type ClusterAlertHandlerFunc 

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

func NewClusterAlertLifecycleAdapter 

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

type 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 

func (in *ClusterAlertRuleList) DeepCopy() *ClusterAlertRuleList

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

func (*ClusterAlertRuleList) DeepCopyInto 

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

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

func (*ClusterAlertRuleList) DeepCopyObject 

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

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

type ClusterAlertRuleLister 

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

type ClusterAlertRuleSpec 

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

func (*ClusterAlertRuleSpec) DeepCopy 

func (in *ClusterAlertRuleSpec) DeepCopy() *ClusterAlertRuleSpec

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

func (*ClusterAlertRuleSpec) DeepCopyInto 

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

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

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 

func (in *ClusterComponentStatus) DeepCopy() *ClusterComponentStatus

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

func (*ClusterComponentStatus) DeepCopyInto 

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

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

type ClusterCondition 

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

func (*ClusterCondition) DeepCopy 

func (in *ClusterCondition) DeepCopy() *ClusterCondition

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

func (*ClusterCondition) DeepCopyInto 

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

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

type ClusterConditionType 

type ClusterConditionType string

type ClusterController 

type ClusterController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ClusterLister
	AddHandler(ctx context.Context, name string, handler ClusterHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync ClusterHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler ClusterHandlerFunc)
	Enqueue(namespace, name string)
	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 

func (in *ClusterLoggingStatus) DeepCopy() *ClusterLoggingStatus

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

func (*ClusterLoggingStatus) DeepCopyInto 

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

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

type ClusterLoggingsGetter 

type ClusterLoggingsGetter interface {
	ClusterLoggings(namespace string) ClusterLoggingInterface
}

type ClusterMetricNamesInput 

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

func (*ClusterMetricNamesInput) DeepCopy 

func (in *ClusterMetricNamesInput) DeepCopy() *ClusterMetricNamesInput

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

func (*ClusterMetricNamesInput) DeepCopyInto 

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

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

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)

func NewClusterMonitorGraphLifecycleAdapter 

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

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 

func (in *ClusterMonitorGraphList) DeepCopy() *ClusterMonitorGraphList

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

func (*ClusterMonitorGraphList) DeepCopyInto 

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

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

func (*ClusterMonitorGraphList) DeepCopyObject 

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

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

type ClusterMonitorGraphLister 

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

type ClusterMonitorGraphSpec 

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

func (*ClusterMonitorGraphSpec) DeepCopy 

func (in *ClusterMonitorGraphSpec) DeepCopy() *ClusterMonitorGraphSpec

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

func (*ClusterMonitorGraphSpec) DeepCopyInto 

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

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

type ClusterMonitorGraphsGetter 

type ClusterMonitorGraphsGetter interface {
	ClusterMonitorGraphs(namespace string) ClusterMonitorGraphInterface
}

type ClusterRegistrationToken 

type ClusterRegistrationToken struct {
	types.Namespaced

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

func NewClusterRegistrationToken 

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

func (*ClusterRegistrationToken) DeepCopy 

func (in *ClusterRegistrationToken) DeepCopy() *ClusterRegistrationToken

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

func (*ClusterRegistrationToken) DeepCopyInto 

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

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

func (*ClusterRegistrationToken) DeepCopyObject 

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

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

type ClusterRegistrationTokenChangeHandlerFunc 

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

type ClusterRegistrationTokenClient 

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

	Cache() ClusterRegistrationTokenClientCache

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

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

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)

func NewClusterRegistrationTokenLifecycleAdapter 

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

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 

func (in *ClusterRegistrationTokenList) DeepCopy() *ClusterRegistrationTokenList

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

func (*ClusterRegistrationTokenList) DeepCopyInto 

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

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

func (*ClusterRegistrationTokenList) DeepCopyObject 

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

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

type ClusterRegistrationTokenLister 

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

type ClusterRegistrationTokenSpec 

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

func (*ClusterRegistrationTokenSpec) DeepCopy 

func (in *ClusterRegistrationTokenSpec) DeepCopy() *ClusterRegistrationTokenSpec

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

func (*ClusterRegistrationTokenSpec) DeepCopyInto 

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

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

type ClusterRegistrationTokenStatus 

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

func (*ClusterRegistrationTokenStatus) DeepCopy 

func (in *ClusterRegistrationTokenStatus) DeepCopy() *ClusterRegistrationTokenStatus

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

func (*ClusterRegistrationTokenStatus) DeepCopyInto 

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

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

type ClusterRegistrationTokensGetter 

type ClusterRegistrationTokensGetter interface {
	ClusterRegistrationTokens(namespace string) ClusterRegistrationTokenInterface
}

type ClusterRoleTemplateBinding 

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

	UserName           string `json:"userName,omitempty" norman:"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 

func (in *ClusterRoleTemplateBinding) DeepCopy() *ClusterRoleTemplateBinding

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

func (*ClusterRoleTemplateBinding) DeepCopyInto 

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

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

func (*ClusterRoleTemplateBinding) DeepCopyObject 

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

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

type ClusterRoleTemplateBindingChangeHandlerFunc 

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

type ClusterRoleTemplateBindingClient 

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

	Cache() ClusterRoleTemplateBindingClientCache

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

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

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)

func NewClusterRoleTemplateBindingLifecycleAdapter 

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

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 

func (in *ClusterRoleTemplateBindingList) DeepCopy() *ClusterRoleTemplateBindingList

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

func (*ClusterRoleTemplateBindingList) DeepCopyInto 

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

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

func (*ClusterRoleTemplateBindingList) DeepCopyObject 

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

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

type ClusterRoleTemplateBindingLister 

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

type ClusterRoleTemplateBindingsGetter 

type ClusterRoleTemplateBindingsGetter interface {
	ClusterRoleTemplateBindings(namespace string) ClusterRoleTemplateBindingInterface
}

type ClusterScan 

type ClusterScan struct {
	types.Namespaced

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

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

func NewClusterScan 

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

func (*ClusterScan) DeepCopy 

func (in *ClusterScan) DeepCopy() *ClusterScan

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

func (*ClusterScan) DeepCopyInto 

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

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

func (*ClusterScan) DeepCopyObject 

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

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

type ClusterScanChangeHandlerFunc 

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

type 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 

func (in *ClusterScanCondition) DeepCopy() *ClusterScanCondition

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

func (*ClusterScanCondition) DeepCopyInto 

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

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

type ClusterScanConfig 

type ClusterScanConfig struct {
}

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 

func (in *ClusterTemplateQuestionsOutput) DeepCopy() *ClusterTemplateQuestionsOutput

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

func (*ClusterTemplateQuestionsOutput) DeepCopyInto 

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

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

type ClusterTemplateRevision 

type ClusterTemplateRevision struct {
	types.Namespaced

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

func NewClusterTemplateRevision 

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

func (*ClusterTemplateRevision) DeepCopy 

func (in *ClusterTemplateRevision) DeepCopy() *ClusterTemplateRevision

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

func (*ClusterTemplateRevision) DeepCopyInto 

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

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

func (*ClusterTemplateRevision) DeepCopyObject 

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

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

type ClusterTemplateRevisionChangeHandlerFunc 

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

type ClusterTemplateRevisionClient 

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

	Cache() ClusterTemplateRevisionClientCache

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

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

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)

func NewClusterTemplateRevisionLifecycleAdapter 

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

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 

func (in *ClusterTemplateRevisionList) DeepCopy() *ClusterTemplateRevisionList

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

func (*ClusterTemplateRevisionList) DeepCopyInto 

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

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

func (*ClusterTemplateRevisionList) DeepCopyObject 

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

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

type ClusterTemplateRevisionLister 

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

type ClusterTemplateRevisionSpec 

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

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

func (*ClusterTemplateRevisionSpec) DeepCopy 

func (in *ClusterTemplateRevisionSpec) DeepCopy() *ClusterTemplateRevisionSpec

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

func (*ClusterTemplateRevisionSpec) DeepCopyInto 

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

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

type 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 

func (in *CommonMonitorGraphSpec) DeepCopy() *CommonMonitorGraphSpec

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

func (*CommonMonitorGraphSpec) DeepCopyInto 

func (in *CommonMonitorGraphSpec) DeepCopyInto(out *CommonMonitorGraphSpec)

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

type CommonQueryMetricInput 

type CommonQueryMetricInput struct {
	From     string `json:"from,omitempty"`
	To       string `json:"to,omitempty"`
	Interval string `json:"interval,omitempty"`
	Expr     string `json:"expr,omitempty" norman:"required"`
}

func (*CommonQueryMetricInput) DeepCopy 

func (in *CommonQueryMetricInput) DeepCopy() *CommonQueryMetricInput

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

func (*CommonQueryMetricInput) DeepCopyInto 

func (in *CommonQueryMetricInput) DeepCopyInto(out *CommonQueryMetricInput)

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

type CommonRuleField 

type CommonRuleField struct {
	DisplayName string `json:"displayName,omitempty"`
	Severity    string `json:"severity,omitempty" norman:"required,options=info|critical|warning,default=critical"`
	Inherited   *bool  `json:"inherited,omitempty" norman:"default=true"`
	TimingField
}

func (*CommonRuleField) DeepCopy 

func (in *CommonRuleField) DeepCopy() *CommonRuleField

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

func (*CommonRuleField) DeepCopyInto 

func (in *CommonRuleField) DeepCopyInto(out *CommonRuleField)

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

type ComposeCondition 

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

func (*ComposeCondition) DeepCopy 

func (in *ComposeCondition) DeepCopy() *ComposeCondition

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

func (*ComposeCondition) DeepCopyInto 

func (in *ComposeCondition) DeepCopyInto(out *ComposeCondition)

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

type ComposeConfig 

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

func NewComposeConfig 

func NewComposeConfig(namespace, name string, obj ComposeConfig) *ComposeConfig

func (*ComposeConfig) DeepCopy 

func (in *ComposeConfig) DeepCopy() *ComposeConfig

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

func (*ComposeConfig) DeepCopyInto 

func (in *ComposeConfig) DeepCopyInto(out *ComposeConfig)

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

func (*ComposeConfig) DeepCopyObject 

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

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

type ComposeConfigChangeHandlerFunc 

type ComposeConfigChangeHandlerFunc func(obj *ComposeConfig) (runtime.Object, error)

type 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 

func (in *ContainerResourceLimit) DeepCopy() *ContainerResourceLimit

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

func (*ContainerResourceLimit) DeepCopyInto 

func (in *ContainerResourceLimit) DeepCopyInto(out *ContainerResourceLimit)

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

type CustomConfig 

type CustomConfig struct {
	// IP or FQDN that is fully resolvable and used for SSH communication
	Address string `yaml:"address" json:"address,omitempty"`
	// Optional - Internal address that will be used for components communication
	InternalAddress string `yaml:"internal_address" json:"internalAddress,omitempty"`
	// SSH user that will be used by RKE
	User string `yaml:"user" json:"user,omitempty"`
	// Optional - Docker socket on the node that will be used in tunneling
	DockerSocket string `yaml:"docker_socket" json:"dockerSocket,omitempty"`
	// SSH Private Key
	SSHKey string `yaml:"ssh_key" json:"sshKey,omitempty" norman:"type=password"`
	// SSH Certificate
	SSHCert string            `yaml:"ssh_cert" json:"sshCert,omitempty"`
	Label   map[string]string `yaml:"label" json:"label,omitempty"`
}

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 

func (in *FlannelNetworkProvider) DeepCopy() *FlannelNetworkProvider

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

func (*FlannelNetworkProvider) DeepCopyInto 

func (in *FlannelNetworkProvider) DeepCopyInto(out *FlannelNetworkProvider)

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

type FluentForwarderConfig 

type FluentForwarderConfig struct {
	EnableTLS     bool           `json:"enableTls,omitempty" norman:"default=false"`
	Certificate   string         `json:"certificate,omitempty"`
	Compress      bool           `json:"compress,omitempty" norman:"default=true"`
	FluentServers []FluentServer `json:"fluentServers,omitempty" norman:"required"`
}

func (*FluentForwarderConfig) DeepCopy 

func (in *FluentForwarderConfig) DeepCopy() *FluentForwarderConfig

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

func (*FluentForwarderConfig) DeepCopyInto 

func (in *FluentForwarderConfig) DeepCopyInto(out *FluentForwarderConfig)

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

type FluentServer 

type FluentServer struct {
	Endpoint  string `json:"endpoint,omitempty" norman:"required"`
	Hostname  string `json:"hostname,omitempty"`
	Weight    int    `json:"weight,omitempty" norman:"default=100"`
	Standby   bool   `json:"standby,omitempty" norman:"default=false"`
	Username  string `json:"username,omitempty"`
	Password  string `json:"password,omitempty" norman:"type=password"`
	SharedKey string `json:"sharedKey,omitempty" norman:"type=password"`
}

func (*FluentServer) DeepCopy 

func (in *FluentServer) DeepCopy() *FluentServer

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

func (*FluentServer) DeepCopyInto 

func (in *FluentServer) DeepCopyInto(out *FluentServer)

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

type FreeIpaConfig 

type FreeIpaConfig struct {
	LdapConfig `json:",inline" mapstructure:",squash"`
}

func (*FreeIpaConfig) DeepCopy 

func (in *FreeIpaConfig) DeepCopy() *FreeIpaConfig

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

func (*FreeIpaConfig) DeepCopyInto 

func (in *FreeIpaConfig) DeepCopyInto(out *FreeIpaConfig)

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

func (*FreeIpaConfig) DeepCopyObject 

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

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

type FreeIpaTestAndApplyInput 

type FreeIpaTestAndApplyInput struct {
	LdapTestAndApplyInput `json:",inline" mapstructure:",squash"`
}

func (*FreeIpaTestAndApplyInput) DeepCopy 

func (in *FreeIpaTestAndApplyInput) DeepCopy() *FreeIpaTestAndApplyInput

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

func (*FreeIpaTestAndApplyInput) DeepCopyInto 

func (in *FreeIpaTestAndApplyInput) DeepCopyInto(out *FreeIpaTestAndApplyInput)

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

func (*FreeIpaTestAndApplyInput) DeepCopyObject 

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

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

type GenerateKubeConfigOutput 

type GenerateKubeConfigOutput struct {
	Config string `json:"config"`
}

func (*GenerateKubeConfigOutput) DeepCopy 

func (in *GenerateKubeConfigOutput) DeepCopy() *GenerateKubeConfigOutput

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

func (*GenerateKubeConfigOutput) DeepCopyInto 

func (in *GenerateKubeConfigOutput) DeepCopyInto(out *GenerateKubeConfigOutput)

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

type GithubConfig 

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

	Hostname     string `json:"hostname,omitempty" norman:"default=github.com" norman:"required"`
	TLS          bool   `json:"tls,omitempty" norman:"notnullable,default=true" norman:"required"`
	ClientID     string `json:"clientId,omitempty" norman:"required"`
	ClientSecret string `json:"clientSecret,omitempty" norman:"required,type=password"`
}

func (*GithubConfig) DeepCopy 

func (in *GithubConfig) DeepCopy() *GithubConfig

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

func (*GithubConfig) DeepCopyInto 

func (in *GithubConfig) DeepCopyInto(out *GithubConfig)

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

func (*GithubConfig) DeepCopyObject 

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

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

type GithubConfigApplyInput 

type GithubConfigApplyInput struct {
	GithubConfig GithubConfig `json:"githubConfig,omitempty"`
	Code         string       `json:"code,omitempty"`
	Enabled      bool         `json:"enabled,omitempty"`
}

func (*GithubConfigApplyInput) DeepCopy 

func (in *GithubConfigApplyInput) DeepCopy() *GithubConfigApplyInput

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

func (*GithubConfigApplyInput) DeepCopyInto 

func (in *GithubConfigApplyInput) DeepCopyInto(out *GithubConfigApplyInput)

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

type GithubConfigTestOutput 

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

func (*GithubConfigTestOutput) DeepCopy 

func (in *GithubConfigTestOutput) DeepCopy() *GithubConfigTestOutput

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

func (*GithubConfigTestOutput) DeepCopyInto 

func (in *GithubConfigTestOutput) DeepCopyInto(out *GithubConfigTestOutput)

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

type GlobalAwsOpts 

type GlobalAwsOpts struct {
	// TODO: Is there any use for this?  We can get it from the instance metadata service
	// Maybe if we're not running on AWS, e.g. bootstrap; for now it is not very useful
	Zone string `json:"zone" yaml:"zone" ini:"Zone,omitempty"`

	// The AWS VPC flag enables the possibility to run the master components
	// on a different aws account, on a different cloud provider or on-premises.
	// If the flag is set also the KubernetesClusterTag must be provided
	VPC string `json:"vpc" yaml:"vpc" ini:"VPC,omitempty"`
	// SubnetID enables using a specific subnet to use for ELB's
	SubnetID string `json:"subnet-id" yaml:"subnet-id" ini:"SubnetID,omitempty"`
	// RouteTableID enables using a specific RouteTable
	RouteTableID string `json:"routetable-id" yaml:"routetable-id" ini:"RouteTableID,omitempty"`

	// RoleARN is the IAM role to assume when interaction with AWS APIs.
	RoleARN string `json:"role-arn" yaml:"role-arn" ini:"RoleARN,omitempty"`

	// KubernetesClusterTag is the legacy cluster id we'll use to identify our cluster resources
	KubernetesClusterTag string `json:"kubernetes-cluster-tag" yaml:"kubernetes-cluster-tag" ini:"KubernetesClusterTag,omitempty"`
	// KubernetesClusterID is the cluster id we'll use to identify our cluster resources
	KubernetesClusterID string `json:"kubernetes-cluster-id" yaml:"kubernetes-cluster-id" ini:"KubernetesClusterID,omitempty"`

	//The aws provider creates an inbound rule per load balancer on the node security
	//group. However, this can run into the AWS security group rule limit of 50 if
	//many LoadBalancers are created.
	//
	//This flag disables the automatic ingress creation. It requires that the user
	//has setup a rule that allows inbound traffic on kubelet ports from the
	//local VPC subnet (so load balancers can access it). E.g. 10.82.0.0/16 30000-32000.
	DisableSecurityGroupIngress bool `json:"disable-security-group-ingress" yaml:"disable-security-group-ingress" ini:"DisableSecurityGroupIngress,omitempty"`

	//AWS has a hard limit of 500 security groups. For large clusters creating a security group for each ELB
	//can cause the max number of security groups to be reached. If this is set instead of creating a new
	//Security group for each ELB this security group will be used instead.
	ElbSecurityGroup string `json:"elb-security-group" yaml:"elb-security-group" ini:"ElbSecurityGroup,omitempty"`

	//During the instantiation of an new AWS cloud provider, the detected region
	//is validated against a known set of regions.
	//
	//In a non-standard, AWS like environment (e.g. Eucalyptus), this check may
	//be undesirable.  Setting this to true will disable the check and provide
	//a warning that the check was skipped.  Please note that this is an
	//experimental feature and work-in-progress for the moment.  If you find
	//yourself in an non-AWS cloud and open an issue, please indicate that in the
	//issue body.
	DisableStrictZoneCheck bool `json:"disable-strict-zone-check" yaml:"disable-strict-zone-check" ini:"DisableStrictZoneCheck,omitempty"`
}

func (*GlobalAwsOpts) DeepCopy 

func (in *GlobalAwsOpts) DeepCopy() *GlobalAwsOpts

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

func (*GlobalAwsOpts) DeepCopyInto 

func (in *GlobalAwsOpts) DeepCopyInto(out *GlobalAwsOpts)

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

type GlobalDNS 

type GlobalDNS struct {
	types.Namespaced

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

	Spec   GlobalDNSSpec   `json:"spec,omitempty"`
	Status GlobalDNSStatus `json:"status,omitempty"`
}

func NewGlobalDNS 

func NewGlobalDNS(namespace, name string, obj GlobalDNS) *GlobalDNS

func (*GlobalDNS) DeepCopy 

func (in *GlobalDNS) DeepCopy() *GlobalDNS

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

func (*GlobalDNS) DeepCopyInto 

func (in *GlobalDNS) DeepCopyInto(out *GlobalDNS)

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

func (*GlobalDNS) DeepCopyObject 

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

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

type GlobalDNSChangeHandlerFunc 

type GlobalDNSChangeHandlerFunc func(obj *GlobalDNS) (runtime.Object, error)

type 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 

func (in *GlobalDNSProviderList) DeepCopy() *GlobalDNSProviderList

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

func (*GlobalDNSProviderList) DeepCopyInto 

func (in *GlobalDNSProviderList) DeepCopyInto(out *GlobalDNSProviderList)

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

func (*GlobalDNSProviderList) DeepCopyObject 

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

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

type GlobalDNSProviderLister 

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

type GlobalDNSProviderSpec 

type GlobalDNSProviderSpec struct {
	Route53ProviderConfig    *Route53ProviderConfig    `json:"route53ProviderConfig,omitempty"`
	CloudflareProviderConfig *CloudflareProviderConfig `json:"cloudflareProviderConfig,omitempty"`
	AlidnsProviderConfig     *AlidnsProviderConfig     `json:"alidnsProviderConfig,omitempty"`
	Members                  []Member                  `json:"members,omitempty"`
	RootDomain               string                    `json:"rootDomain"`
}

func (*GlobalDNSProviderSpec) DeepCopy 

func (in *GlobalDNSProviderSpec) DeepCopy() *GlobalDNSProviderSpec

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

func (*GlobalDNSProviderSpec) DeepCopyInto 

func (in *GlobalDNSProviderSpec) DeepCopyInto(out *GlobalDNSProviderSpec)

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

type GlobalDNSProvidersGetter 

type GlobalDNSProvidersGetter interface {
	GlobalDNSProviders(namespace string) GlobalDNSProviderInterface
}

type GlobalDNSSpec 

type GlobalDNSSpec struct {
	FQDN                string   `json:"fqdn,omitempty" norman:"type=hostname,required"`
	TTL                 int64    `json:"ttl,omitempty" norman:"default=300"`
	ProjectNames        []string `json:"projectNames" norman:"type=array[reference[project]],noupdate"`
	MultiClusterAppName string   `json:"multiClusterAppName,omitempty" norman:"type=reference[multiClusterApp]"`
	ProviderName        string   `json:"providerName,omitempty" norman:"type=reference[globalDnsProvider],required"`
	Members             []Member `json:"members,omitempty"`
}

func (*GlobalDNSSpec) DeepCopy 

func (in *GlobalDNSSpec) DeepCopy() *GlobalDNSSpec

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

func (*GlobalDNSSpec) DeepCopyInto 

func (in *GlobalDNSSpec) DeepCopyInto(out *GlobalDNSSpec)

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

type GlobalDNSStatus 

type GlobalDNSStatus struct {
	Endpoints        []string            `json:"endpoints,omitempty"`
	ClusterEndpoints map[string][]string `json:"clusterEndpoints,omitempty"`
}

func (*GlobalDNSStatus) DeepCopy 

func (in *GlobalDNSStatus) DeepCopy() *GlobalDNSStatus

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

func (*GlobalDNSStatus) DeepCopyInto 

func (in *GlobalDNSStatus) DeepCopyInto(out *GlobalDNSStatus)

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

type GlobalDNSsGetter 

type GlobalDNSsGetter interface {
	GlobalDNSs(namespace string) GlobalDNSInterface
}

type GlobalOpenstackOpts 

type GlobalOpenstackOpts struct {
	AuthURL    string `json:"auth-url" yaml:"auth-url" ini:"auth-url,omitempty"`
	Username   string `json:"username" yaml:"username" ini:"username,omitempty"`
	UserID     string `json:"user-id" yaml:"user-id" ini:"user-id,omitempty"`
	Password   string `json:"password" yaml:"password" ini:"password,omitempty" norman:"type=password"`
	TenantID   string `json:"tenant-id" yaml:"tenant-id" ini:"tenant-id,omitempty"`
	TenantName string `json:"tenant-name" yaml:"tenant-name" ini:"tenant-name,omitempty"`
	TrustID    string `json:"trust-id" yaml:"trust-id" ini:"trust-id,omitempty"`
	DomainID   string `json:"domain-id" yaml:"domain-id" ini:"domain-id,omitempty"`
	DomainName string `json:"domain-name" yaml:"domain-name" ini:"domain-name,omitempty"`
	Region     string `json:"region" yaml:"region" ini:"region,omitempty"`
	CAFile     string `json:"ca-file" yaml:"ca-file" ini:"ca-file,omitempty"`
}

func (*GlobalOpenstackOpts) DeepCopy 

func (in *GlobalOpenstackOpts) DeepCopy() *GlobalOpenstackOpts

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

func (*GlobalOpenstackOpts) DeepCopyInto 

func (in *GlobalOpenstackOpts) DeepCopyInto(out *GlobalOpenstackOpts)

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

type GlobalRole 

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

	DisplayName    string              `json:"displayName,omitempty" norman:"required,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 

func (in *GlobalRoleBindingList) DeepCopy() *GlobalRoleBindingList

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

func (*GlobalRoleBindingList) DeepCopyInto 

func (in *GlobalRoleBindingList) DeepCopyInto(out *GlobalRoleBindingList)

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

func (*GlobalRoleBindingList) DeepCopyObject 

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

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

type GlobalRoleBindingLister 

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

type GlobalRoleBindingsGetter 

type GlobalRoleBindingsGetter interface {
	GlobalRoleBindings(namespace string) GlobalRoleBindingInterface
}

type GlobalRoleChangeHandlerFunc 

type GlobalRoleChangeHandlerFunc func(obj *GlobalRole) (runtime.Object, error)

type 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 

func (in *GoogleOauthConfigApplyInput) DeepCopy() *GoogleOauthConfigApplyInput

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

func (*GoogleOauthConfigApplyInput) DeepCopyInto 

func (in *GoogleOauthConfigApplyInput) DeepCopyInto(out *GoogleOauthConfigApplyInput)

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

type GoogleOauthConfigTestOutput 

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

func (*GoogleOauthConfigTestOutput) DeepCopy 

func (in *GoogleOauthConfigTestOutput) DeepCopy() *GoogleOauthConfigTestOutput

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

func (*GoogleOauthConfigTestOutput) DeepCopyInto 

func (in *GoogleOauthConfigTestOutput) DeepCopyInto(out *GoogleOauthConfigTestOutput)

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

type Group 

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

	DisplayName string `json:"displayName,omitempty"`
}

func NewGroup 

func NewGroup(namespace, name string, obj Group) *Group

func (*Group) DeepCopy 

func (in *Group) DeepCopy() *Group

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

func (*Group) DeepCopyInto 

func (in *Group) DeepCopyInto(out *Group)

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

func (*Group) DeepCopyObject 

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

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

type GroupChangeHandlerFunc 

type GroupChangeHandlerFunc func(obj *Group) (runtime.Object, error)

type 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 

func (in *ImportClusterYamlInput) DeepCopy() *ImportClusterYamlInput

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

func (*ImportClusterYamlInput) DeepCopyInto 

func (in *ImportClusterYamlInput) DeepCopyInto(out *ImportClusterYamlInput)

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

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 

type Interface interface {
	RESTClient() rest.Interface
	controller.Starter

	NodePoolsGetter
	NodesGetter
	NodeDriversGetter
	NodeTemplatesGetter
	ProjectsGetter
	GlobalRolesGetter
	GlobalRoleBindingsGetter
	RoleTemplatesGetter
	PodSecurityPolicyTemplatesGetter
	PodSecurityPolicyTemplateProjectBindingsGetter
	ClusterRoleTemplateBindingsGetter
	ProjectRoleTemplateBindingsGetter
	ClustersGetter
	ClusterRegistrationTokensGetter
	CatalogsGetter
	TemplatesGetter
	CatalogTemplatesGetter
	CatalogTemplateVersionsGetter
	TemplateVersionsGetter
	TemplateContentsGetter
	GroupsGetter
	GroupMembersGetter
	PrincipalsGetter
	UsersGetter
	AuthConfigsGetter
	LdapConfigsGetter
	TokensGetter
	DynamicSchemasGetter
	PreferencesGetter
	UserAttributesGetter
	ProjectNetworkPoliciesGetter
	ClusterLoggingsGetter
	ProjectLoggingsGetter
	ListenConfigsGetter
	SettingsGetter
	FeaturesGetter
	ClusterAlertsGetter
	ProjectAlertsGetter
	NotifiersGetter
	ClusterAlertGroupsGetter
	ProjectAlertGroupsGetter
	ClusterAlertRulesGetter
	ProjectAlertRulesGetter
	ComposeConfigsGetter
	ProjectCatalogsGetter
	ClusterCatalogsGetter
	MultiClusterAppsGetter
	MultiClusterAppRevisionsGetter
	GlobalDNSsGetter
	GlobalDNSProvidersGetter
	KontainerDriversGetter
	EtcdBackupsGetter
	ClusterScansGetter
	MonitorMetricsGetter
	ClusterMonitorGraphsGetter
	ProjectMonitorGraphsGetter
	CloudCredentialsGetter
	ClusterTemplatesGetter
	ClusterTemplateRevisionsGetter
	RKEK8sSystemImagesGetter
	RKEK8sServiceOptionsGetter
	RKEAddonsGetter
	RKEK8sWindowsSystemImagesGetter
}

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 

func (in *KontainerDriverStatus) DeepCopy() *KontainerDriverStatus

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

func (*KontainerDriverStatus) DeepCopyInto 

func (in *KontainerDriverStatus) DeepCopyInto(out *KontainerDriverStatus)

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

type KontainerDriversGetter 

type KontainerDriversGetter interface {
	KontainerDrivers(namespace string) KontainerDriverInterface
}

type KubeAPIService 

type KubeAPIService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
	// Virtual IP range that will be used by Kubernetes services
	ServiceClusterIPRange string `yaml:"service_cluster_ip_range" json:"serviceClusterIpRange,omitempty"`
	// Port range for services defined with NodePort type
	ServiceNodePortRange string `yaml:"service_node_port_range" json:"serviceNodePortRange,omitempty" norman:"default=30000-32767"`
	// Enabled/Disable PodSecurityPolicy
	PodSecurityPolicy bool `yaml:"pod_security_policy" json:"podSecurityPolicy,omitempty"`
	// Enable/Disable AlwaysPullImages admissions plugin
	AlwaysPullImages bool `yaml:"always_pull_images" json:"alwaysPullImages,omitempty"`
}

func (*KubeAPIService) DeepCopy 

func (in *KubeAPIService) DeepCopy() *KubeAPIService

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

func (*KubeAPIService) DeepCopyInto 

func (in *KubeAPIService) DeepCopyInto(out *KubeAPIService)

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

type KubeControllerService 

type KubeControllerService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
	// CIDR Range for Pods in cluster
	ClusterCIDR string `yaml:"cluster_cidr" json:"clusterCidr,omitempty"`
	// Virtual IP range that will be used by Kubernetes services
	ServiceClusterIPRange string `yaml:"service_cluster_ip_range" json:"serviceClusterIpRange,omitempty"`
}

func (*KubeControllerService) DeepCopy 

func (in *KubeControllerService) DeepCopy() *KubeControllerService

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

func (*KubeControllerService) DeepCopyInto 

func (in *KubeControllerService) DeepCopyInto(out *KubeControllerService)

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

type KubeletService 

type KubeletService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
	// Domain of the cluster (default: "cluster.local")
	ClusterDomain string `yaml:"cluster_domain" json:"clusterDomain,omitempty"`
	// The image whose network/ipc namespaces containers in each pod will use
	InfraContainerImage string `yaml:"infra_container_image" json:"infraContainerImage,omitempty"`
	// Cluster DNS service ip
	ClusterDNSServer string `yaml:"cluster_dns_server" json:"clusterDnsServer,omitempty"`
	// Fail if swap is enabled
	FailSwapOn bool `yaml:"fail_swap_on" json:"failSwapOn,omitempty"`
}

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 

func (in *KubernetesServicesOptions) DeepCopy() *KubernetesServicesOptions

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

func (*KubernetesServicesOptions) DeepCopyInto 

func (in *KubernetesServicesOptions) DeepCopyInto(out *KubernetesServicesOptions)

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

type LdapConfig 

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

	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 

func (in *LdapTestAndApplyInput) DeepCopy() *LdapTestAndApplyInput

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

func (*LdapTestAndApplyInput) DeepCopyInto 

func (in *LdapTestAndApplyInput) DeepCopyInto(out *LdapTestAndApplyInput)

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

func (*LdapTestAndApplyInput) DeepCopyObject 

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

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

type 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 

func (in *LoadBalancerCapabilities) DeepCopy() *LoadBalancerCapabilities

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

func (*LoadBalancerCapabilities) DeepCopyInto 

func (in *LoadBalancerCapabilities) DeepCopyInto(out *LoadBalancerCapabilities)

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

type LoadBalancerOpenstackOpts 

type LoadBalancerOpenstackOpts struct {
	LBVersion            string `json:"lb-version" yaml:"lb-version" ini:"lb-version,omitempty"`                            // overrides autodetection. Only support v2.
	UseOctavia           bool   `json:"use-octavia" yaml:"use-octavia" ini:"use-octavia,omitempty"`                         // uses Octavia V2 service catalog endpoint
	SubnetID             string `json:"subnet-id" yaml:"subnet-id" ini:"subnet-id,omitempty"`                               // overrides autodetection.
	FloatingNetworkID    string `json:"floating-network-id" yaml:"floating-network-id" ini:"floating-network-id,omitempty"` // If specified, will create floating ip for loadbalancer, or do not create floating ip.
	LBMethod             string `json:"lb-method" yaml:"lb-method" ini:"lb-method,omitempty"`                               // default to ROUND_ROBIN.
	LBProvider           string `json:"lb-provider" yaml:"lb-provider" ini:"lb-provider,omitempty"`
	CreateMonitor        bool   `json:"create-monitor" yaml:"create-monitor" ini:"create-monitor,omitempty"`
	MonitorDelay         string `json:"monitor-delay" yaml:"monitor-delay" ini:"monitor-delay,omitempty"`
	MonitorTimeout       string `json:"monitor-timeout" yaml:"monitor-timeout" ini:"monitor-timeout,omitempty"`
	MonitorMaxRetries    int    `json:"monitor-max-retries" yaml:"monitor-max-retries" ini:"monitor-max-retries,omitempty"`
	ManageSecurityGroups bool   `json:"manage-security-groups" yaml:"manage-security-groups" ini:"manage-security-groups,omitempty"`
}

func (*LoadBalancerOpenstackOpts) DeepCopy 

func (in *LoadBalancerOpenstackOpts) DeepCopy() *LoadBalancerOpenstackOpts

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

func (*LoadBalancerOpenstackOpts) DeepCopyInto 

func (in *LoadBalancerOpenstackOpts) DeepCopyInto(out *LoadBalancerOpenstackOpts)

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

type LocalClusterAuthEndpoint 

type LocalClusterAuthEndpoint struct {
	Enabled bool   `json:"enabled"`
	FQDN    string `json:"fqdn,omitempty"`
	CACerts string `json:"caCerts,omitempty"`
}

func (*LocalClusterAuthEndpoint) DeepCopy 

func (in *LocalClusterAuthEndpoint) DeepCopy() *LocalClusterAuthEndpoint

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

func (*LocalClusterAuthEndpoint) DeepCopyInto 

func (in *LocalClusterAuthEndpoint) DeepCopyInto(out *LocalClusterAuthEndpoint)

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

type LocalConfig 

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

func (*LocalConfig) DeepCopy 

func (in *LocalConfig) DeepCopy() *LocalConfig

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

func (*LocalConfig) DeepCopyInto 

func (in *LocalConfig) DeepCopyInto(out *LocalConfig)

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

func (*LocalConfig) DeepCopyObject 

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

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

type LoggingCommonField 

type LoggingCommonField struct {
	DisplayName         string            `json:"displayName,omitempty"`
	OutputFlushInterval int               `json:"outputFlushInterval,omitempty" norman:"default=60"`
	OutputTags          map[string]string `json:"outputTags,omitempty"`
}

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 

func (in *MetadataOpenstackOpts) DeepCopy() *MetadataOpenstackOpts

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

func (*MetadataOpenstackOpts) DeepCopyInto 

func (in *MetadataOpenstackOpts) DeepCopyInto(out *MetadataOpenstackOpts)

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

type 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 

func (in *MultiClusterAppRevision) DeepCopy() *MultiClusterAppRevision

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

func (*MultiClusterAppRevision) DeepCopyInto 

func (in *MultiClusterAppRevision) DeepCopyInto(out *MultiClusterAppRevision)

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

func (*MultiClusterAppRevision) DeepCopyObject 

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

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

type MultiClusterAppRevisionChangeHandlerFunc 

type MultiClusterAppRevisionChangeHandlerFunc func(obj *MultiClusterAppRevision) (runtime.Object, error)

type MultiClusterAppRevisionClient 

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

	Cache() MultiClusterAppRevisionClientCache

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

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

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)

func NewMultiClusterAppRevisionLifecycleAdapter 

func NewMultiClusterAppRevisionLifecycleAdapter(name string, clusterScoped bool, client MultiClusterAppRevisionInterface, l MultiClusterAppRevisionLifecycle) MultiClusterAppRevisionHandlerFunc

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 

func (in *MultiClusterAppRevisionList) DeepCopy() *MultiClusterAppRevisionList

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

func (*MultiClusterAppRevisionList) DeepCopyInto 

func (in *MultiClusterAppRevisionList) DeepCopyInto(out *MultiClusterAppRevisionList)

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

func (*MultiClusterAppRevisionList) DeepCopyObject 

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

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

type MultiClusterAppRevisionLister 

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

type MultiClusterAppRevisionsGetter 

type MultiClusterAppRevisionsGetter interface {
	MultiClusterAppRevisions(namespace string) MultiClusterAppRevisionInterface
}

type MultiClusterAppRollbackInput 

type MultiClusterAppRollbackInput struct {
	RevisionName string `json:"revisionName,omitempty" norman:"type=reference[multiClusterAppRevision]"`
}

func (*MultiClusterAppRollbackInput) DeepCopy 

func (in *MultiClusterAppRollbackInput) DeepCopy() *MultiClusterAppRollbackInput

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

func (*MultiClusterAppRollbackInput) DeepCopyInto 

func (in *MultiClusterAppRollbackInput) DeepCopyInto(out *MultiClusterAppRollbackInput)

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

type MultiClusterAppSpec 

type MultiClusterAppSpec struct {
	TemplateVersionName  string          `json:"templateVersionName,omitempty" norman:"type=reference[templateVersion],required"`
	Answers              []Answer        `json:"answers,omitempty"`
	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 

func (in *MultiClusterAppStatus) DeepCopy() *MultiClusterAppStatus

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

func (*MultiClusterAppStatus) DeepCopyInto 

func (in *MultiClusterAppStatus) DeepCopyInto(out *MultiClusterAppStatus)

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

type MultiClusterAppsGetter 

type MultiClusterAppsGetter interface {
	MultiClusterApps(namespace string) MultiClusterAppInterface
}

type NamespaceResourceQuota 

type NamespaceResourceQuota struct {
	Limit ResourceQuotaLimit `json:"limit,omitempty"`
}

func (*NamespaceResourceQuota) DeepCopy 

func (in *NamespaceResourceQuota) DeepCopy() *NamespaceResourceQuota

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

func (*NamespaceResourceQuota) DeepCopyInto 

func (in *NamespaceResourceQuota) DeepCopyInto(out *NamespaceResourceQuota)

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

type NetworkConfig 

type NetworkConfig struct {
	// Network Plugin That will be used in kubernetes cluster
	Plugin string `yaml:"plugin" json:"plugin,omitempty" norman:"default=canal"`
	// Plugin options to configure network properties
	Options map[string]string `yaml:"options" json:"options,omitempty"`
	// 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 

func (in *NodeTemplateCondition) DeepCopy() *NodeTemplateCondition

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

func (*NodeTemplateCondition) DeepCopyInto 

func (in *NodeTemplateCondition) DeepCopyInto(out *NodeTemplateCondition)

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

type NodeTemplateController 

type NodeTemplateController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() NodeTemplateLister
	AddHandler(ctx context.Context, name string, handler NodeTemplateHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodeTemplateHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeTemplateHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler NodeTemplateHandlerFunc)
	Enqueue(namespace, name string)
	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 

func (in *OpenLdapTestAndApplyInput) DeepCopy() *OpenLdapTestAndApplyInput

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

func (*OpenLdapTestAndApplyInput) DeepCopyInto 

func (in *OpenLdapTestAndApplyInput) DeepCopyInto(out *OpenLdapTestAndApplyInput)

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

func (*OpenLdapTestAndApplyInput) DeepCopyObject 

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

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

type OpenstackCloudProvider 

type OpenstackCloudProvider struct {
	Global       GlobalOpenstackOpts       `json:"global" yaml:"global" ini:"Global,omitempty"`
	LoadBalancer LoadBalancerOpenstackOpts `json:"loadBalancer" yaml:"load_balancer" ini:"LoadBalancer,omitempty"`
	BlockStorage BlockStorageOpenstackOpts `json:"blockStorage" yaml:"block_storage" ini:"BlockStorage,omitempty"`
	Route        RouteOpenstackOpts        `json:"route" yaml:"route" ini:"Route,omitempty"`
	Metadata     MetadataOpenstackOpts     `json:"metadata" yaml:"metadata" ini:"Metadata,omitempty"`
}

OpenstackCloudProvider options

func (*OpenstackCloudProvider) DeepCopy 

func (in *OpenstackCloudProvider) DeepCopy() *OpenstackCloudProvider

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

func (*OpenstackCloudProvider) DeepCopyInto 

func (in *OpenstackCloudProvider) DeepCopyInto(out *OpenstackCloudProvider)

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

type PagerdutyConfig 

type PagerdutyConfig struct {
	ServiceKey string `json:"serviceKey,omitempty" norman:"required"`
	*HTTPClientConfig
}

func (*PagerdutyConfig) DeepCopy 

func (in *PagerdutyConfig) DeepCopy() *PagerdutyConfig

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

func (*PagerdutyConfig) DeepCopyInto 

func (in *PagerdutyConfig) DeepCopyInto(out *PagerdutyConfig)

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

type PingConfig 

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

func (*PingConfig) DeepCopy 

func (in *PingConfig) DeepCopy() *PingConfig

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

func (*PingConfig) DeepCopyInto 

func (in *PingConfig) DeepCopyInto(out *PingConfig)

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

func (*PingConfig) DeepCopyObject 

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

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

type PodRule 

type PodRule struct {
	PodName                string `json:"podName,omitempty" norman:"required,type=reference[/v3/projects/schemas/pod]"`
	Condition              string `json:"condition,omitempty" norman:"required,options=notrunning|notscheduled|restarts,default=notrunning"`
	RestartTimes           int    `json:"restartTimes,omitempty" norman:"min=1,default=3"`
	RestartIntervalSeconds int    `json:"restartIntervalSeconds,omitempty"  norman:"min=1,default=300"`
}

func (*PodRule) DeepCopy 

func (in *PodRule) DeepCopy() *PodRule

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

func (*PodRule) DeepCopyInto 

func (in *PodRule) DeepCopyInto(out *PodRule)

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

type PodSecurityPolicyTemplate 

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

	Description string                      `json:"description"`
	Spec        extv1.PodSecurityPolicySpec `json:"spec,omitempty"`
}

func NewPodSecurityPolicyTemplate 

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

func (*PodSecurityPolicyTemplate) DeepCopy 

func (in *PodSecurityPolicyTemplate) DeepCopy() *PodSecurityPolicyTemplate

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

func (*PodSecurityPolicyTemplate) DeepCopyInto 

func (in *PodSecurityPolicyTemplate) DeepCopyInto(out *PodSecurityPolicyTemplate)

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

func (*PodSecurityPolicyTemplate) DeepCopyObject 

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

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

type PodSecurityPolicyTemplateChangeHandlerFunc 

type PodSecurityPolicyTemplateChangeHandlerFunc func(obj *PodSecurityPolicyTemplate) (runtime.Object, error)

type PodSecurityPolicyTemplateClient 

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

	Cache() PodSecurityPolicyTemplateClientCache

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

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

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)

func NewPodSecurityPolicyTemplateLifecycleAdapter 

func NewPodSecurityPolicyTemplateLifecycleAdapter(name string, clusterScoped bool, client PodSecurityPolicyTemplateInterface, l PodSecurityPolicyTemplateLifecycle) PodSecurityPolicyTemplateHandlerFunc

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 

func (in *PodSecurityPolicyTemplateList) DeepCopy() *PodSecurityPolicyTemplateList

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

func (*PodSecurityPolicyTemplateList) DeepCopyInto 

func (in *PodSecurityPolicyTemplateList) DeepCopyInto(out *PodSecurityPolicyTemplateList)

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

func (*PodSecurityPolicyTemplateList) DeepCopyObject 

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

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

type PodSecurityPolicyTemplateLister 

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

type PodSecurityPolicyTemplateProjectBinding 

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

	PodSecurityPolicyTemplateName string `json:"podSecurityPolicyTemplateId" norman:"required,type=reference[podSecurityPolicyTemplate]"`
	TargetProjectName             string `json:"targetProjectId" norman:"required,type=reference[project]"`
}

func NewPodSecurityPolicyTemplateProjectBinding 

func NewPodSecurityPolicyTemplateProjectBinding(namespace, name string, obj PodSecurityPolicyTemplateProjectBinding) *PodSecurityPolicyTemplateProjectBinding

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopy 

func (in *PodSecurityPolicyTemplateProjectBinding) DeepCopy() *PodSecurityPolicyTemplateProjectBinding

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

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopyInto 

func (in *PodSecurityPolicyTemplateProjectBinding) DeepCopyInto(out *PodSecurityPolicyTemplateProjectBinding)

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

func (*PodSecurityPolicyTemplateProjectBinding) DeepCopyObject 

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

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

type PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc 

type PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc func(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error)

type PodSecurityPolicyTemplateProjectBindingClient 

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

	Cache() PodSecurityPolicyTemplateProjectBindingClientCache

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

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

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 PodSecurityPolicyTemplateProjectBindingHandlerFunc 

type PodSecurityPolicyTemplateProjectBindingHandlerFunc func(key string, obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error)

func NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter 

func NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter(name string, clusterScoped bool, client PodSecurityPolicyTemplateProjectBindingInterface, l PodSecurityPolicyTemplateProjectBindingLifecycle) PodSecurityPolicyTemplateProjectBindingHandlerFunc

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

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

type PodSecurityPolicyTemplateProjectBindingList 

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

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopy 

func (in *PodSecurityPolicyTemplateProjectBindingList) DeepCopy() *PodSecurityPolicyTemplateProjectBindingList

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

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopyInto 

func (in *PodSecurityPolicyTemplateProjectBindingList) DeepCopyInto(out *PodSecurityPolicyTemplateProjectBindingList)

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

func (*PodSecurityPolicyTemplateProjectBindingList) DeepCopyObject 

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

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

type PodSecurityPolicyTemplateProjectBindingLister 

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

type PodSecurityPolicyTemplateProjectBindingsGetter 

type PodSecurityPolicyTemplateProjectBindingsGetter interface {
	PodSecurityPolicyTemplateProjectBindings(namespace string) PodSecurityPolicyTemplateProjectBindingInterface
}

type PodSecurityPolicyTemplatesGetter 

type PodSecurityPolicyTemplatesGetter interface {
	PodSecurityPolicyTemplates(namespace string) PodSecurityPolicyTemplateInterface
}

type PortCheck 

type PortCheck struct {
	// Portcheck address to check.
	Address string `json:"address,omitempty"`
	// Port number
	Port int `json:"port,omitempty"`
	// Port Protocol
	Protocol string `json:"protocol,omitempty"`
}

func (*PortCheck) DeepCopy 

func (in *PortCheck) DeepCopy() *PortCheck

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

func (*PortCheck) DeepCopyInto 

func (in *PortCheck) DeepCopyInto(out *PortCheck)

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

type Preference 

type Preference struct {
	types.Namespaced

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

	Value string `json:"value" norman:"required"`
}

func NewPreference 

func NewPreference(namespace, name string, obj Preference) *Preference

func (*Preference) DeepCopy 

func (in *Preference) DeepCopy() *Preference

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

func (*Preference) DeepCopyInto 

func (in *Preference) DeepCopyInto(out *Preference)

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

func (*Preference) DeepCopyObject 

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

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

type PreferenceChangeHandlerFunc 

type PreferenceChangeHandlerFunc func(obj *Preference) (runtime.Object, error)

type 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 

func (in *ProjectAlertGroupList) DeepCopy() *ProjectAlertGroupList

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

func (*ProjectAlertGroupList) DeepCopyInto 

func (in *ProjectAlertGroupList) DeepCopyInto(out *ProjectAlertGroupList)

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

func (*ProjectAlertGroupList) DeepCopyObject 

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

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

type ProjectAlertGroupLister 

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

type ProjectAlertGroupsGetter 

type ProjectAlertGroupsGetter interface {
	ProjectAlertGroups(namespace string) ProjectAlertGroupInterface
}

type ProjectAlertHandlerFunc 

type ProjectAlertHandlerFunc func(key string, obj *ProjectAlert) (runtime.Object, error)

func NewProjectAlertLifecycleAdapter 

func NewProjectAlertLifecycleAdapter(name string, clusterScoped bool, client ProjectAlertInterface, l ProjectAlertLifecycle) ProjectAlertHandlerFunc

type 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 

func (in *ProjectAlertRuleList) DeepCopy() *ProjectAlertRuleList

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

func (*ProjectAlertRuleList) DeepCopyInto 

func (in *ProjectAlertRuleList) DeepCopyInto(out *ProjectAlertRuleList)

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

func (*ProjectAlertRuleList) DeepCopyObject 

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

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

type ProjectAlertRuleLister 

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

type ProjectAlertRuleSpec 

type ProjectAlertRuleSpec struct {
	CommonRuleField
	ProjectName  string        `json:"projectName" norman:"type=reference[project]"`
	GroupName    string        `json:"groupName" norman:"type=reference[projectAlertGroup]"`
	PodRule      *PodRule      `json:"podRule,omitempty"`
	WorkloadRule *WorkloadRule `json:"workloadRule,omitempty"`
	MetricRule   *MetricRule   `json:"metricRule,omitempty"`
}

func (*ProjectAlertRuleSpec) DeepCopy 

func (in *ProjectAlertRuleSpec) DeepCopy() *ProjectAlertRuleSpec

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

func (*ProjectAlertRuleSpec) DeepCopyInto 

func (in *ProjectAlertRuleSpec) DeepCopyInto(out *ProjectAlertRuleSpec)

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

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 

func (in *ProjectLoggingStatus) DeepCopy() *ProjectLoggingStatus

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

func (*ProjectLoggingStatus) DeepCopyInto 

func (in *ProjectLoggingStatus) DeepCopyInto(out *ProjectLoggingStatus)

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

type ProjectLoggingsGetter 

type ProjectLoggingsGetter interface {
	ProjectLoggings(namespace string) ProjectLoggingInterface
}

type ProjectMetricNamesInput 

type ProjectMetricNamesInput struct {
	ProjectName string `json:"projectId" norman:"type=reference[project]"`
}

func (*ProjectMetricNamesInput) DeepCopy 

func (in *ProjectMetricNamesInput) DeepCopy() *ProjectMetricNamesInput

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

func (*ProjectMetricNamesInput) DeepCopyInto 

func (in *ProjectMetricNamesInput) DeepCopyInto(out *ProjectMetricNamesInput)

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

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)

func NewProjectMonitorGraphLifecycleAdapter 

func NewProjectMonitorGraphLifecycleAdapter(name string, clusterScoped bool, client ProjectMonitorGraphInterface, l ProjectMonitorGraphLifecycle) ProjectMonitorGraphHandlerFunc

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 

func (in *ProjectMonitorGraphList) DeepCopy() *ProjectMonitorGraphList

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

func (*ProjectMonitorGraphList) DeepCopyInto 

func (in *ProjectMonitorGraphList) DeepCopyInto(out *ProjectMonitorGraphList)

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

func (*ProjectMonitorGraphList) DeepCopyObject 

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

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

type ProjectMonitorGraphLister 

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

type ProjectMonitorGraphSpec 

type ProjectMonitorGraphSpec struct {
	ProjectName         string `json:"projectName" norman:"type=reference[project]"`
	ResourceType        string `json:"resourceType,omitempty" norman:"type=enum,options=workload|pod|container"`
	DisplayResourceType string `json:"displayResourceType,omitempty" norman:"type=enum,options=workload|pod|container"`
	CommonMonitorGraphSpec
}

func (*ProjectMonitorGraphSpec) DeepCopy 

func (in *ProjectMonitorGraphSpec) DeepCopy() *ProjectMonitorGraphSpec

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

func (*ProjectMonitorGraphSpec) DeepCopyInto 

func (in *ProjectMonitorGraphSpec) DeepCopyInto(out *ProjectMonitorGraphSpec)

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

type ProjectMonitorGraphsGetter 

type ProjectMonitorGraphsGetter interface {
	ProjectMonitorGraphs(namespace string) ProjectMonitorGraphInterface
}

type ProjectNetworkPoliciesGetter 

type ProjectNetworkPoliciesGetter interface {
	ProjectNetworkPolicies(namespace string) ProjectNetworkPolicyInterface
}

type ProjectNetworkPolicy 

type ProjectNetworkPolicy struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              ProjectNetworkPolicySpec    `json:"spec"`
	Status            *ProjectNetworkPolicyStatus `json:"status"`
}

func NewProjectNetworkPolicy 

func NewProjectNetworkPolicy(namespace, name string, obj ProjectNetworkPolicy) *ProjectNetworkPolicy

func (*ProjectNetworkPolicy) DeepCopy 

func (in *ProjectNetworkPolicy) DeepCopy() *ProjectNetworkPolicy

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

func (*ProjectNetworkPolicy) DeepCopyInto 

func (in *ProjectNetworkPolicy) DeepCopyInto(out *ProjectNetworkPolicy)

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

func (*ProjectNetworkPolicy) DeepCopyObject 

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

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

type ProjectNetworkPolicyChangeHandlerFunc 

type ProjectNetworkPolicyChangeHandlerFunc func(obj *ProjectNetworkPolicy) (runtime.Object, error)

type ProjectNetworkPolicyClient 

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

	Cache() ProjectNetworkPolicyClientCache

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

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

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)

func NewProjectNetworkPolicyLifecycleAdapter 

func NewProjectNetworkPolicyLifecycleAdapter(name string, clusterScoped bool, client ProjectNetworkPolicyInterface, l ProjectNetworkPolicyLifecycle) ProjectNetworkPolicyHandlerFunc

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 

func (in *ProjectNetworkPolicyList) DeepCopy() *ProjectNetworkPolicyList

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

func (*ProjectNetworkPolicyList) DeepCopyInto 

func (in *ProjectNetworkPolicyList) DeepCopyInto(out *ProjectNetworkPolicyList)

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

func (*ProjectNetworkPolicyList) DeepCopyObject 

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

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

type ProjectNetworkPolicyLister 

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

type ProjectNetworkPolicySpec 

type ProjectNetworkPolicySpec struct {
	ProjectName string `json:"projectName,omitempty" norman:"required,type=reference[project]"`
	Description string `json:"description"`
}

func (*ProjectNetworkPolicySpec) DeepCopy 

func (in *ProjectNetworkPolicySpec) DeepCopy() *ProjectNetworkPolicySpec

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

func (*ProjectNetworkPolicySpec) DeepCopyInto 

func (in *ProjectNetworkPolicySpec) DeepCopyInto(out *ProjectNetworkPolicySpec)

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

type ProjectNetworkPolicyStatus 

type ProjectNetworkPolicyStatus struct {
}

func (*ProjectNetworkPolicyStatus) DeepCopy 

func (in *ProjectNetworkPolicyStatus) DeepCopy() *ProjectNetworkPolicyStatus

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

func (*ProjectNetworkPolicyStatus) DeepCopyInto 

func (in *ProjectNetworkPolicyStatus) DeepCopyInto(out *ProjectNetworkPolicyStatus)

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

type ProjectResourceQuota 

type ProjectResourceQuota struct {
	Limit     ResourceQuotaLimit `json:"limit,omitempty"`
	UsedLimit ResourceQuotaLimit `json:"usedLimit,omitempty"`
}

func (*ProjectResourceQuota) DeepCopy 

func (in *ProjectResourceQuota) DeepCopy() *ProjectResourceQuota

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

func (*ProjectResourceQuota) DeepCopyInto 

func (in *ProjectResourceQuota) DeepCopyInto(out *ProjectResourceQuota)

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

type ProjectRoleTemplateBinding 

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

	UserName           string `json:"userName,omitempty" norman:"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 

func (in *ProjectRoleTemplateBinding) DeepCopy() *ProjectRoleTemplateBinding

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

func (*ProjectRoleTemplateBinding) DeepCopyInto 

func (in *ProjectRoleTemplateBinding) DeepCopyInto(out *ProjectRoleTemplateBinding)

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

func (*ProjectRoleTemplateBinding) DeepCopyObject 

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

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

type ProjectRoleTemplateBindingChangeHandlerFunc 

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

type ProjectRoleTemplateBindingClient 

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

	Cache() ProjectRoleTemplateBindingClientCache

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

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

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)

func NewProjectRoleTemplateBindingLifecycleAdapter 

func NewProjectRoleTemplateBindingLifecycleAdapter(name string, clusterScoped bool, client ProjectRoleTemplateBindingInterface, l ProjectRoleTemplateBindingLifecycle) ProjectRoleTemplateBindingHandlerFunc

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 

func (in *ProjectRoleTemplateBindingList) DeepCopy() *ProjectRoleTemplateBindingList

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

func (*ProjectRoleTemplateBindingList) DeepCopyInto 

func (in *ProjectRoleTemplateBindingList) DeepCopyInto(out *ProjectRoleTemplateBindingList)

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

func (*ProjectRoleTemplateBindingList) DeepCopyObject 

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

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

type ProjectRoleTemplateBindingLister 

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

type ProjectRoleTemplateBindingsGetter 

type ProjectRoleTemplateBindingsGetter interface {
	ProjectRoleTemplateBindings(namespace string) ProjectRoleTemplateBindingInterface
}

type ProjectSpec 

type ProjectSpec struct {
	DisplayName                   string                  `json:"displayName,omitempty" norman:"required"`
	Description                   string                  `json:"description"`
	ClusterName                   string                  `json:"clusterName,omitempty" norman:"required,type=reference[cluster]"`
	ResourceQuota                 *ProjectResourceQuota   `json:"resourceQuota,omitempty"`
	NamespaceDefaultResourceQuota *NamespaceResourceQuota `json:"namespaceDefaultResourceQuota,omitempty"`
	ContainerDefaultResourceLimit *ContainerResourceLimit `json:"containerDefaultResourceLimit,omitempty"`
	EnableProjectMonitoring       bool                    `json:"enableProjectMonitoring" norman:"default=false"`
}

func (*ProjectSpec) DeepCopy 

func (in *ProjectSpec) DeepCopy() *ProjectSpec

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

func (*ProjectSpec) DeepCopyInto 

func (in *ProjectSpec) DeepCopyInto(out *ProjectSpec)

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

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 

func (in *QueryClusterGraphOutput) DeepCopy() *QueryClusterGraphOutput

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

func (*QueryClusterGraphOutput) DeepCopyInto 

func (in *QueryClusterGraphOutput) DeepCopyInto(out *QueryClusterGraphOutput)

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

type QueryClusterMetricInput 

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

func (*QueryClusterMetricInput) DeepCopy 

func (in *QueryClusterMetricInput) DeepCopy() *QueryClusterMetricInput

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

func (*QueryClusterMetricInput) DeepCopyInto 

func (in *QueryClusterMetricInput) DeepCopyInto(out *QueryClusterMetricInput)

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

type QueryGraphInput 

type QueryGraphInput struct {
	From         string            `json:"from,omitempty"`
	To           string            `json:"to,omitempty"`
	Interval     string            `json:"interval,omitempty"`
	MetricParams map[string]string `json:"metricParams,omitempty"`
	Filters      map[string]string `json:"filters,omitempty"`
	IsDetails    bool              `json:"isDetails,omitempty"`
}

func (*QueryGraphInput) DeepCopy 

func (in *QueryGraphInput) DeepCopy() *QueryGraphInput

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

func (*QueryGraphInput) DeepCopyInto 

func (in *QueryGraphInput) DeepCopyInto(out *QueryGraphInput)

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

type QueryMetricOutput 

type QueryMetricOutput struct {
	Type   string        `json:"type,omitempty"`
	Series []*TimeSeries `json:"series" norman:"type=array[reference[timeSeries]]"`
}

func (*QueryMetricOutput) DeepCopy 

func (in *QueryMetricOutput) DeepCopy() *QueryMetricOutput

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

func (*QueryMetricOutput) DeepCopyInto 

func (in *QueryMetricOutput) DeepCopyInto(out *QueryMetricOutput)

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

type QueryProjectGraph 

type QueryProjectGraph struct {
	GraphName string        `json:"graphID" norman:"type=reference[projectMonitorGraph]"`
	Series    []*TimeSeries `json:"series" norman:"type=array[reference[timeSeries]]"`
}

func (*QueryProjectGraph) DeepCopy 

func (in *QueryProjectGraph) DeepCopy() *QueryProjectGraph

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

func (*QueryProjectGraph) DeepCopyInto 

func (in *QueryProjectGraph) DeepCopyInto(out *QueryProjectGraph)

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

type QueryProjectGraphOutput 

type QueryProjectGraphOutput struct {
	Type string              `json:"type,omitempty"`
	Data []QueryProjectGraph `json:"data,omitempty"`
}

func (*QueryProjectGraphOutput) DeepCopy 

func (in *QueryProjectGraphOutput) DeepCopy() *QueryProjectGraphOutput

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

func (*QueryProjectGraphOutput) DeepCopyInto 

func (in *QueryProjectGraphOutput) DeepCopyInto(out *QueryProjectGraphOutput)

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

type QueryProjectMetricInput 

type QueryProjectMetricInput struct {
	ProjectName string `json:"projectId" norman:"type=reference[project]"`
	CommonQueryMetricInput
}

func (*QueryProjectMetricInput) DeepCopy 

func (in *QueryProjectMetricInput) DeepCopy() *QueryProjectMetricInput

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

func (*QueryProjectMetricInput) DeepCopyInto 

func (in *QueryProjectMetricInput) DeepCopyInto(out *QueryProjectMetricInput)

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

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)

func NewRKEK8sServiceOptionLifecycleAdapter 

func NewRKEK8sServiceOptionLifecycleAdapter(name string, clusterScoped bool, client RKEK8sServiceOptionInterface, l RKEK8sServiceOptionLifecycle) RKEK8sServiceOptionHandlerFunc

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 

func (in *RKEK8sServiceOptionList) DeepCopy() *RKEK8sServiceOptionList

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

func (*RKEK8sServiceOptionList) DeepCopyInto 

func (in *RKEK8sServiceOptionList) DeepCopyInto(out *RKEK8sServiceOptionList)

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

func (*RKEK8sServiceOptionList) DeepCopyObject 

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

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

type RKEK8sServiceOptionLister 

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

type RKEK8sServiceOptionsGetter 

type RKEK8sServiceOptionsGetter interface {
	RKEK8sServiceOptions(namespace string) RKEK8sServiceOptionInterface
}

type RKEK8sSystemImage 

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

	SystemImages RKESystemImages `yaml:"system_images" json:"systemImages,omitempty"`
}

func NewRKEK8sSystemImage 

func NewRKEK8sSystemImage(namespace, name string, obj RKEK8sSystemImage) *RKEK8sSystemImage

func (*RKEK8sSystemImage) DeepCopy 

func (in *RKEK8sSystemImage) DeepCopy() *RKEK8sSystemImage

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

func (*RKEK8sSystemImage) DeepCopyInto 

func (in *RKEK8sSystemImage) DeepCopyInto(out *RKEK8sSystemImage)

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

func (*RKEK8sSystemImage) DeepCopyObject 

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

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

type RKEK8sSystemImageChangeHandlerFunc 

type RKEK8sSystemImageChangeHandlerFunc func(obj *RKEK8sSystemImage) (runtime.Object, error)

type 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 

func (in *RKEK8sSystemImageList) DeepCopy() *RKEK8sSystemImageList

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

func (*RKEK8sSystemImageList) DeepCopyInto 

func (in *RKEK8sSystemImageList) DeepCopyInto(out *RKEK8sSystemImageList)

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

func (*RKEK8sSystemImageList) DeepCopyObject 

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

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

type RKEK8sSystemImageLister 

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

type RKEK8sSystemImagesGetter 

type RKEK8sSystemImagesGetter interface {
	RKEK8sSystemImages(namespace string) RKEK8sSystemImageInterface
}

type 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 

func (in *RKEK8sWindowsSystemImage) DeepCopy() *RKEK8sWindowsSystemImage

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 RKEK8sWindowsSystemImageClient 

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

	Cache() RKEK8sWindowsSystemImageClientCache

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

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

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)

func NewRKEK8sWindowsSystemImageLifecycleAdapter 

func NewRKEK8sWindowsSystemImageLifecycleAdapter(name string, clusterScoped bool, client RKEK8sWindowsSystemImageInterface, l RKEK8sWindowsSystemImageLifecycle) RKEK8sWindowsSystemImageHandlerFunc

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 

func (in *RKEK8sWindowsSystemImageList) DeepCopy() *RKEK8sWindowsSystemImageList

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

func (*RKEK8sWindowsSystemImageList) DeepCopyInto 

func (in *RKEK8sWindowsSystemImageList) DeepCopyInto(out *RKEK8sWindowsSystemImageList)

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 

func (in *RancherKubernetesEngineConfig) DeepCopy() *RancherKubernetesEngineConfig

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

func (*RancherKubernetesEngineConfig) DeepCopyInto 

func (in *RancherKubernetesEngineConfig) DeepCopyInto(out *RancherKubernetesEngineConfig)

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

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 

func (in *RestoreFromEtcdBackupInput) DeepCopy() *RestoreFromEtcdBackupInput

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

func (*RestoreFromEtcdBackupInput) DeepCopyInto 

func (in *RestoreFromEtcdBackupInput) DeepCopyInto(out *RestoreFromEtcdBackupInput)

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

type RoleTemplate 

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

	DisplayName           string              `json:"displayName,omitempty" norman:"required"`
	Description           string              `json:"description"`
	Rules                 []rbacv1.PolicyRule `json:"rules,omitempty"`
	Builtin               bool                `json:"builtin" norman:"nocreate,noupdate"`
	External              bool                `json:"external"`
	Hidden                bool                `json:"hidden"`
	Locked                bool                `json:"locked,omitempty" norman:"type=boolean"`
	ClusterCreatorDefault bool                `json:"clusterCreatorDefault,omitempty" norman:"required"`
	ProjectCreatorDefault bool                `json:"projectCreatorDefault,omitempty" norman:"required"`
	Context               string              `json:"context" norman:"type=string,options=project|cluster"`
	RoleTemplateNames     []string            `json:"roleTemplateNames,omitempty" norman:"type=array[reference[roleTemplate]]"`
	Administrative        bool                `json:"administrative,omitempty"`
}

func NewRoleTemplate 

func NewRoleTemplate(namespace, name string, obj RoleTemplate) *RoleTemplate

func (*RoleTemplate) DeepCopy 

func (in *RoleTemplate) DeepCopy() *RoleTemplate

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

func (*RoleTemplate) DeepCopyInto 

func (in *RoleTemplate) DeepCopyInto(out *RoleTemplate)

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

func (*RoleTemplate) DeepCopyObject 

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

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

type RoleTemplateChangeHandlerFunc 

type RoleTemplateChangeHandlerFunc func(obj *RoleTemplate) (runtime.Object, error)

type 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 

func (in *RotateCertificateInput) DeepCopy() *RotateCertificateInput

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

func (*RotateCertificateInput) DeepCopyInto 

func (in *RotateCertificateInput) DeepCopyInto(out *RotateCertificateInput)

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

type RotateCertificateOutput 

type RotateCertificateOutput struct {
	Message string `json:"message,omitempty"`
}

func (*RotateCertificateOutput) DeepCopy 

func (in *RotateCertificateOutput) DeepCopy() *RotateCertificateOutput

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

func (*RotateCertificateOutput) DeepCopyInto 

func (in *RotateCertificateOutput) DeepCopyInto(out *RotateCertificateOutput)

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

type RotateCertificates 

type RotateCertificates struct {
	// Rotate CA Certificates
	CACertificates bool `json:"caCertificates,omitempty"`
	// Services to rotate their certs
	Services []string `` /* 130-byte string literal not displayed */
}

func (*RotateCertificates) DeepCopy 

func (in *RotateCertificates) DeepCopy() *RotateCertificates

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

func (*RotateCertificates) DeepCopyInto 

func (in *RotateCertificates) DeepCopyInto(out *RotateCertificates)

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

type Route53ProviderConfig 

type Route53ProviderConfig struct {
	AccessKey       string `json:"accessKey" norman:"notnullable,required,minLength=1"`
	SecretKey       string `json:"secretKey" norman:"notnullable,required,minLength=1,type=password"`
	CredentialsPath string `json:"credentialsPath" norman:"default=/.aws"`
	RoleArn         string `json:"roleArn,omitempty"`
	Region          string `json:"region" norman:"default=us-east-1"`
	ZoneType        string `json:"zoneType" norman:"default=public"`
}

func (*Route53ProviderConfig) DeepCopy 

func (in *Route53ProviderConfig) DeepCopy() *Route53ProviderConfig

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

func (*Route53ProviderConfig) DeepCopyInto 

func (in *Route53ProviderConfig) DeepCopyInto(out *Route53ProviderConfig)

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

type RouteOpenstackOpts 

type RouteOpenstackOpts struct {
	RouterID string `json:"router-id" yaml:"router-id" ini:"router-id,omitempty"` // required
}

func (*RouteOpenstackOpts) DeepCopy 

func (in *RouteOpenstackOpts) DeepCopy() *RouteOpenstackOpts

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

func (*RouteOpenstackOpts) DeepCopyInto 

func (in *RouteOpenstackOpts) DeepCopyInto(out *RouteOpenstackOpts)

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

type S3BackupConfig 

type S3BackupConfig struct {
	// Access key ID
	AccessKey string `yaml:"access_key" json:"accessKey,omitempty"`
	// Secret access key
	SecretKey string `yaml:"secret_key" json:"secretKey,omitempty" norman:"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 

func (in *SamlConfigTestOutput) DeepCopy() *SamlConfigTestOutput

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

func (*SamlConfigTestOutput) DeepCopyInto 

func (in *SamlConfigTestOutput) DeepCopyInto(out *SamlConfigTestOutput)

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

type SchedulerService 

type SchedulerService struct {
	// Base service properties
	BaseService `yaml:",inline" json:",inline"`
}

func (*SchedulerService) DeepCopy 

func (in *SchedulerService) DeepCopy() *SchedulerService

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

func (*SchedulerService) DeepCopyInto 

func (in *SchedulerService) DeepCopyInto(out *SchedulerService)

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

type SearchPrincipalsInput 

type SearchPrincipalsInput struct {
	Name          string `json:"name" norman:"type=string,required,notnullable"`
	PrincipalType string `json:"principalType,omitempty" norman:"type=enum,options=user|group"`
}

func (*SearchPrincipalsInput) DeepCopy 

func (in *SearchPrincipalsInput) DeepCopy() *SearchPrincipalsInput

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

func (*SearchPrincipalsInput) DeepCopyInto 

func (in *SearchPrincipalsInput) DeepCopyInto(out *SearchPrincipalsInput)

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

type ServiceOverride 

type ServiceOverride struct {
	Service       string `json:"service" yaml:"service" ini:"Service,omitempty"`
	Region        string `json:"region" yaml:"region" ini:"Region,omitempty"`
	URL           string `json:"url" yaml:"url" ini:"URL,omitempty"`
	SigningRegion string `json:"signing-region" yaml:"signing-region" ini:"SigningRegion,omitempty"`
	SigningMethod string `json:"signing-method" yaml:"signing-method" ini:"SigningMethod,omitempty"`
	SigningName   string `json:"signing-name" yaml:"signing-name" ini:"SigningName,omitempty"`
}

func (*ServiceOverride) DeepCopy 

func (in *ServiceOverride) DeepCopy() *ServiceOverride

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

func (*ServiceOverride) DeepCopyInto 

func (in *ServiceOverride) DeepCopyInto(out *ServiceOverride)

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

type SetPasswordInput 

type SetPasswordInput struct {
	NewPassword string `json:"newPassword" norman:"type=string,required"`
}

func (*SetPasswordInput) DeepCopy 

func (in *SetPasswordInput) DeepCopy() *SetPasswordInput

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

func (*SetPasswordInput) DeepCopyInto 

func (in *SetPasswordInput) DeepCopyInto(out *SetPasswordInput)

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

type SetPodSecurityPolicyTemplateInput 

type SetPodSecurityPolicyTemplateInput struct {
	PodSecurityPolicyTemplateName string `json:"podSecurityPolicyTemplateId" norman:"required,type=reference[podSecurityPolicyTemplate]"`
}

func (*SetPodSecurityPolicyTemplateInput) DeepCopy 

func (in *SetPodSecurityPolicyTemplateInput) DeepCopy() *SetPodSecurityPolicyTemplateInput

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

func (*SetPodSecurityPolicyTemplateInput) DeepCopyInto 

func (in *SetPodSecurityPolicyTemplateInput) DeepCopyInto(out *SetPodSecurityPolicyTemplateInput)

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

type Setting 

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

	Value      string `json:"value" norman:"required"`
	Default    string `json:"default" norman:"nocreate,noupdate"`
	Customized bool   `json:"customized" norman:"nocreate,noupdate"`
	Source     string `json:"source" norman:"nocreate,noupdate,options=db|default|env"`
}

func NewSetting 

func NewSetting(namespace, name string, obj Setting) *Setting

func (*Setting) DeepCopy 

func (in *Setting) DeepCopy() *Setting

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

func (*Setting) DeepCopyInto 

func (in *Setting) DeepCopyInto(out *Setting)

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

func (*Setting) DeepCopyObject 

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

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

type SettingChangeHandlerFunc 

type SettingChangeHandlerFunc func(obj *Setting) (runtime.Object, error)

type 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 

func (in *TemplateVersionStatus) DeepCopy() *TemplateVersionStatus

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

func (*TemplateVersionStatus) DeepCopyInto 

func (in *TemplateVersionStatus) DeepCopyInto(out *TemplateVersionStatus)

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

type TemplateVersionsGetter 

type TemplateVersionsGetter interface {
	TemplateVersions(namespace string) TemplateVersionInterface
}

type TemplatesGetter 

type TemplatesGetter interface {
	Templates(namespace string) TemplateInterface
}

type TimeSeries 

type TimeSeries struct {
	Name   string      `json:"name"`
	Points [][]float64 `json:"points" norman:"type=array[array[float]]"`
}

func (*TimeSeries) DeepCopy 

func (in *TimeSeries) DeepCopy() *TimeSeries

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

func (*TimeSeries) DeepCopyInto 

func (in *TimeSeries) DeepCopyInto(out *TimeSeries)

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

type TimingField 

type TimingField struct {
	GroupWaitSeconds      int `json:"groupWaitSeconds,omitempty" norman:"required,default=30,min=1"`
	GroupIntervalSeconds  int `json:"groupIntervalSeconds,omitempty" norman:"required,default=180,min=1"`
	RepeatIntervalSeconds int `json:"repeatIntervalSeconds,omitempty"  norman:"required,default=3600,min=1"`
}

func (*TimingField) DeepCopy 

func (in *TimingField) DeepCopy() *TimingField

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

func (*TimingField) DeepCopyInto 

func (in *TimingField) DeepCopyInto(out *TimingField)

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

type Token 

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

	Token           string            `json:"token" norman:"writeOnly,noupdate"`
	UserPrincipal   Principal         `json:"userPrincipal" norman:"type=reference[principal]"`
	GroupPrincipals []Principal       `json:"groupPrincipals" norman:"type=array[reference[principal]]"`
	ProviderInfo    map[string]string `json:"providerInfo,omitempty"`
	UserID          string            `json:"userId" norman:"type=reference[user]"`
	AuthProvider    string            `json:"authProvider"`
	TTLMillis       int64             `json:"ttl"`
	LastUpdateTime  string            `json:"lastUpdateTime"`
	IsDerived       bool              `json:"isDerived"`
	Description     string            `json:"description"`
	Expired         bool              `json:"expired"`
	ExpiresAt       string            `json:"expiresAt"`
	Current         bool              `json:"current"`
	ClusterName     string            `json:"clusterName,omitempty" norman:"noupdate,type=reference[cluster]"`
	Enabled         *bool             `json:"enabled,omitempty" norman:"default=true"`
}

func NewToken 

func NewToken(namespace, name string, obj Token) *Token

func (*Token) DeepCopy 

func (in *Token) DeepCopy() *Token

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

func (*Token) DeepCopyInto 

func (in *Token) DeepCopyInto(out *Token)

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

func (*Token) DeepCopyObject 

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

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

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 

func (in *UpdateGlobalDNSTargetsInput) DeepCopy() *UpdateGlobalDNSTargetsInput

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

func (*UpdateGlobalDNSTargetsInput) DeepCopyInto 

func (in *UpdateGlobalDNSTargetsInput) DeepCopyInto(out *UpdateGlobalDNSTargetsInput)

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

type UpdateMultiClusterAppTargetsInput 

type UpdateMultiClusterAppTargetsInput struct {
	Projects []string `json:"projects" norman:"type=array[reference[project]],required"`
	Answers  []Answer `json:"answers"`
}

func (*UpdateMultiClusterAppTargetsInput) DeepCopy 

func (in *UpdateMultiClusterAppTargetsInput) DeepCopy() *UpdateMultiClusterAppTargetsInput

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

func (*UpdateMultiClusterAppTargetsInput) DeepCopyInto 

func (in *UpdateMultiClusterAppTargetsInput) DeepCopyInto(out *UpdateMultiClusterAppTargetsInput)

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

type UpgradeStrategy 

type UpgradeStrategy struct {
	RollingUpdate *RollingUpdate `json:"rollingUpdate,omitempty"`
}

func (*UpgradeStrategy) DeepCopy 

func (in *UpgradeStrategy) DeepCopy() *UpgradeStrategy

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

func (*UpgradeStrategy) DeepCopyInto 

func (in *UpgradeStrategy) DeepCopyInto(out *UpgradeStrategy)

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

type User 

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

	DisplayName        string     `json:"displayName,omitempty"`
	Description        string     `json:"description"`
	Username           string     `json:"username,omitempty"`
	Password           string     `json:"password,omitempty" norman:"writeOnly,noupdate"`
	MustChangePassword bool       `json:"mustChangePassword,omitempty"`
	PrincipalIDs       []string   `json:"principalIds,omitempty" norman:"type=array[reference[principal]]"`
	Me                 bool       `json:"me,omitempty"`
	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 

func (in *VsphereCloudProvider) DeepCopy() *VsphereCloudProvider

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

func (*VsphereCloudProvider) DeepCopyInto 

func (in *VsphereCloudProvider) DeepCopyInto(out *VsphereCloudProvider)

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

type WeaveNetworkProvider 

type WeaveNetworkProvider struct {
	Password string `yaml:"password,omitempty" json:"password,omitempty" norman:"type=password"`
}

func (*WeaveNetworkProvider) DeepCopy 

func (in *WeaveNetworkProvider) DeepCopy() *WeaveNetworkProvider

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

func (*WeaveNetworkProvider) DeepCopyInto 

func (in *WeaveNetworkProvider) DeepCopyInto(out *WeaveNetworkProvider)

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

type WebhookConfig 

type WebhookConfig struct {
	URL string `json:"url,omitempty" norman:"required"`
	*HTTPClientConfig
}

func (*WebhookConfig) DeepCopy 

func (in *WebhookConfig) DeepCopy() *WebhookConfig

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

func (*WebhookConfig) DeepCopyInto 

func (in *WebhookConfig) DeepCopyInto(out *WebhookConfig)

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

type WechatConfig 

type WechatConfig struct {
	DefaultRecipient string `json:"defaultRecipient,omitempty" norman:"required"`
	Secret           string `json:"secret,omitempty" norman:"type=password,required"`
	Agent            string `json:"agent,omitempty" norman:"required"`
	Corp             string `json:"corp,omitempty" norman:"required"`
	RecipientType    string `json:"recipientType,omitempty" norman:"required,options=tag|party|user,default=party"`
	*HTTPClientConfig
}

func (*WechatConfig) DeepCopy 

func (in *WechatConfig) DeepCopy() *WechatConfig

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

func (*WechatConfig) DeepCopyInto 

func (in *WechatConfig) DeepCopyInto(out *WechatConfig)

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

type WindowsSystemImages 

type WindowsSystemImages struct {
	// Windows nginx-proxy image
	NginxProxy string `yaml:"nginx_proxy" json:"nginxProxy,omitempty"`
	// Kubernetes binaries image
	KubernetesBinaries string `yaml:"kubernetes_binaries" json:"kubernetesBinaries,omitempty"`
	// Kubelet pause image
	KubeletPause string `yaml:"kubelet_pause" json:"kubeletPause,omitempty"`
	// Flannel CNI binaries image
	FlannelCNIBinaries string `yaml:"flannel_cni_binaries" json:"flannelCniBinaries,omitempty"`
	// Calico CNI binaries image
	CalicoCNIBinaries string `yaml:"calico_cni_binaries" json:"calicoCniBinaries,omitempty"`
	// Canal CNI binaries image
	CanalCNIBinaries string `yaml:"canal_cni_binaries" json:"canalCniBinaries,omitempty"`
}

func (*WindowsSystemImages) DeepCopy 

func (in *WindowsSystemImages) DeepCopy() *WindowsSystemImages

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

func (*WindowsSystemImages) DeepCopyInto 

func (in *WindowsSystemImages) DeepCopyInto(out *WindowsSystemImages)

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

type WorkloadRule 

type WorkloadRule struct {
	WorkloadID          string            `json:"workloadId,omitempty"`
	Selector            map[string]string `json:"selector,omitempty"`
	AvailablePercentage int               `json:"availablePercentage,omitempty" norman:"required,min=1,max=100,default=70"`
}

func (*WorkloadRule) DeepCopy 

func (in *WorkloadRule) DeepCopy() *WorkloadRule

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

func (*WorkloadRule) DeepCopyInto 

func (in *WorkloadRule) DeepCopyInto(out *WorkloadRule)

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

type WorkspaceVsphereOpts 

type WorkspaceVsphereOpts struct {
	VCenterIP        string `json:"server,omitempty" yaml:"server,omitempty" ini:"server,omitempty"`
	Datacenter       string `json:"datacenter,omitempty" yaml:"datacenter,omitempty" ini:"datacenter,omitempty"`
	Folder           string `json:"folder,omitempty" yaml:"folder,omitempty" ini:"folder,omitempty"`
	DefaultDatastore string `json:"default-datastore,omitempty" yaml:"default-datastore,omitempty" ini:"default-datastore,omitempty"`
	ResourcePoolPath string `json:"resourcepool-path,omitempty" yaml:"resourcepool-path,omitempty" ini:"resourcepool-path,omitempty"`
}

func (*WorkspaceVsphereOpts) DeepCopy 

func (in *WorkspaceVsphereOpts) DeepCopy() *WorkspaceVsphereOpts

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

func (*WorkspaceVsphereOpts) DeepCopyInto 

func (in *WorkspaceVsphereOpts) DeepCopyInto(out *WorkspaceVsphereOpts)

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

type YAxis 

type YAxis struct {
	Unit string `json:"unit,omitempty"`
}

func (*YAxis) DeepCopy 

func (in *YAxis) DeepCopy() *YAxis

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

func (*YAxis) DeepCopyInto 

func (in *YAxis) DeepCopyInto(out *YAxis)

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

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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