in v2/api/containerservice/v1api20210501/storage/managed_cluster_types_gen.go [1656:2094]
func (cluster *ManagedCluster_STATUS) AssignProperties_To_ManagedCluster_STATUS(destination *storage.ManagedCluster_STATUS) error {
// Clone the existing property bag
propertyBag := genruntime.NewPropertyBag(cluster.PropertyBag)
// AadProfile
if cluster.AadProfile != nil {
var aadProfile storage.ManagedClusterAADProfile_STATUS
err := cluster.AadProfile.AssignProperties_To_ManagedClusterAADProfile_STATUS(&aadProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterAADProfile_STATUS() to populate field AadProfile")
}
destination.AadProfile = &aadProfile
} else {
destination.AadProfile = nil
}
// AddonProfiles
if cluster.AddonProfiles != nil {
addonProfileMap := make(map[string]storage.ManagedClusterAddonProfile_STATUS, len(cluster.AddonProfiles))
for addonProfileKey, addonProfileValue := range cluster.AddonProfiles {
// Shadow the loop variable to avoid aliasing
addonProfileValue := addonProfileValue
var addonProfile storage.ManagedClusterAddonProfile_STATUS
err := addonProfileValue.AssignProperties_To_ManagedClusterAddonProfile_STATUS(&addonProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterAddonProfile_STATUS() to populate field AddonProfiles")
}
addonProfileMap[addonProfileKey] = addonProfile
}
destination.AddonProfiles = addonProfileMap
} else {
destination.AddonProfiles = nil
}
// AgentPoolProfiles
if cluster.AgentPoolProfiles != nil {
agentPoolProfileList := make([]storage.ManagedClusterAgentPoolProfile_STATUS, len(cluster.AgentPoolProfiles))
for agentPoolProfileIndex, agentPoolProfileItem := range cluster.AgentPoolProfiles {
// Shadow the loop variable to avoid aliasing
agentPoolProfileItem := agentPoolProfileItem
var agentPoolProfile storage.ManagedClusterAgentPoolProfile_STATUS
err := agentPoolProfileItem.AssignProperties_To_ManagedClusterAgentPoolProfile_STATUS(&agentPoolProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterAgentPoolProfile_STATUS() to populate field AgentPoolProfiles")
}
agentPoolProfileList[agentPoolProfileIndex] = agentPoolProfile
}
destination.AgentPoolProfiles = agentPoolProfileList
} else {
destination.AgentPoolProfiles = nil
}
// ApiServerAccessProfile
if cluster.ApiServerAccessProfile != nil {
var apiServerAccessProfile storage.ManagedClusterAPIServerAccessProfile_STATUS
err := cluster.ApiServerAccessProfile.AssignProperties_To_ManagedClusterAPIServerAccessProfile_STATUS(&apiServerAccessProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterAPIServerAccessProfile_STATUS() to populate field ApiServerAccessProfile")
}
destination.ApiServerAccessProfile = &apiServerAccessProfile
} else {
destination.ApiServerAccessProfile = nil
}
// AutoScalerProfile
if cluster.AutoScalerProfile != nil {
var autoScalerProfile storage.ManagedClusterProperties_AutoScalerProfile_STATUS
err := cluster.AutoScalerProfile.AssignProperties_To_ManagedClusterProperties_AutoScalerProfile_STATUS(&autoScalerProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterProperties_AutoScalerProfile_STATUS() to populate field AutoScalerProfile")
}
destination.AutoScalerProfile = &autoScalerProfile
} else {
destination.AutoScalerProfile = nil
}
// AutoUpgradeProfile
if cluster.AutoUpgradeProfile != nil {
var autoUpgradeProfile storage.ManagedClusterAutoUpgradeProfile_STATUS
err := cluster.AutoUpgradeProfile.AssignProperties_To_ManagedClusterAutoUpgradeProfile_STATUS(&autoUpgradeProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterAutoUpgradeProfile_STATUS() to populate field AutoUpgradeProfile")
}
destination.AutoUpgradeProfile = &autoUpgradeProfile
} else {
destination.AutoUpgradeProfile = nil
}
// AzureMonitorProfile
if propertyBag.Contains("AzureMonitorProfile") {
var azureMonitorProfile storage.ManagedClusterAzureMonitorProfile_STATUS
err := propertyBag.Pull("AzureMonitorProfile", &azureMonitorProfile)
if err != nil {
return eris.Wrap(err, "pulling 'AzureMonitorProfile' from propertyBag")
}
destination.AzureMonitorProfile = &azureMonitorProfile
} else {
destination.AzureMonitorProfile = nil
}
// AzurePortalFQDN
destination.AzurePortalFQDN = genruntime.ClonePointerToString(cluster.AzurePortalFQDN)
// Conditions
destination.Conditions = genruntime.CloneSliceOfCondition(cluster.Conditions)
// CurrentKubernetesVersion
if propertyBag.Contains("CurrentKubernetesVersion") {
var currentKubernetesVersion string
err := propertyBag.Pull("CurrentKubernetesVersion", ¤tKubernetesVersion)
if err != nil {
return eris.Wrap(err, "pulling 'CurrentKubernetesVersion' from propertyBag")
}
destination.CurrentKubernetesVersion = ¤tKubernetesVersion
} else {
destination.CurrentKubernetesVersion = nil
}
// DisableLocalAccounts
if cluster.DisableLocalAccounts != nil {
disableLocalAccount := *cluster.DisableLocalAccounts
destination.DisableLocalAccounts = &disableLocalAccount
} else {
destination.DisableLocalAccounts = nil
}
// DiskEncryptionSetID
destination.DiskEncryptionSetID = genruntime.ClonePointerToString(cluster.DiskEncryptionSetID)
// DnsPrefix
destination.DnsPrefix = genruntime.ClonePointerToString(cluster.DnsPrefix)
// EnablePodSecurityPolicy
if cluster.EnablePodSecurityPolicy != nil {
enablePodSecurityPolicy := *cluster.EnablePodSecurityPolicy
destination.EnablePodSecurityPolicy = &enablePodSecurityPolicy
} else {
destination.EnablePodSecurityPolicy = nil
}
// EnableRBAC
if cluster.EnableRBAC != nil {
enableRBAC := *cluster.EnableRBAC
destination.EnableRBAC = &enableRBAC
} else {
destination.EnableRBAC = nil
}
// ExtendedLocation
if cluster.ExtendedLocation != nil {
var extendedLocation storage.ExtendedLocation_STATUS
err := cluster.ExtendedLocation.AssignProperties_To_ExtendedLocation_STATUS(&extendedLocation)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ExtendedLocation_STATUS() to populate field ExtendedLocation")
}
destination.ExtendedLocation = &extendedLocation
} else {
destination.ExtendedLocation = nil
}
// Fqdn
destination.Fqdn = genruntime.ClonePointerToString(cluster.Fqdn)
// FqdnSubdomain
destination.FqdnSubdomain = genruntime.ClonePointerToString(cluster.FqdnSubdomain)
// HttpProxyConfig
if cluster.HttpProxyConfig != nil {
var httpProxyConfig storage.ManagedClusterHTTPProxyConfig_STATUS
err := cluster.HttpProxyConfig.AssignProperties_To_ManagedClusterHTTPProxyConfig_STATUS(&httpProxyConfig)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterHTTPProxyConfig_STATUS() to populate field HttpProxyConfig")
}
destination.HttpProxyConfig = &httpProxyConfig
} else {
destination.HttpProxyConfig = nil
}
// Id
destination.Id = genruntime.ClonePointerToString(cluster.Id)
// Identity
if cluster.Identity != nil {
var identity storage.ManagedClusterIdentity_STATUS
err := cluster.Identity.AssignProperties_To_ManagedClusterIdentity_STATUS(&identity)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterIdentity_STATUS() to populate field Identity")
}
destination.Identity = &identity
} else {
destination.Identity = nil
}
// IdentityProfile
if cluster.IdentityProfile != nil {
identityProfileMap := make(map[string]storage.UserAssignedIdentity_STATUS, len(cluster.IdentityProfile))
for identityProfileKey, identityProfileValue := range cluster.IdentityProfile {
// Shadow the loop variable to avoid aliasing
identityProfileValue := identityProfileValue
var identityProfile storage.UserAssignedIdentity_STATUS
err := identityProfileValue.AssignProperties_To_UserAssignedIdentity_STATUS(&identityProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_UserAssignedIdentity_STATUS() to populate field IdentityProfile")
}
identityProfileMap[identityProfileKey] = identityProfile
}
destination.IdentityProfile = identityProfileMap
} else {
destination.IdentityProfile = nil
}
// KubernetesVersion
destination.KubernetesVersion = genruntime.ClonePointerToString(cluster.KubernetesVersion)
// LinuxProfile
if cluster.LinuxProfile != nil {
var linuxProfile storage.ContainerServiceLinuxProfile_STATUS
err := cluster.LinuxProfile.AssignProperties_To_ContainerServiceLinuxProfile_STATUS(&linuxProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ContainerServiceLinuxProfile_STATUS() to populate field LinuxProfile")
}
destination.LinuxProfile = &linuxProfile
} else {
destination.LinuxProfile = nil
}
// Location
destination.Location = genruntime.ClonePointerToString(cluster.Location)
// MaxAgentPools
destination.MaxAgentPools = genruntime.ClonePointerToInt(cluster.MaxAgentPools)
// Name
destination.Name = genruntime.ClonePointerToString(cluster.Name)
// NetworkProfile
if cluster.NetworkProfile != nil {
var networkProfile storage.ContainerServiceNetworkProfile_STATUS
err := cluster.NetworkProfile.AssignProperties_To_ContainerServiceNetworkProfile_STATUS(&networkProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ContainerServiceNetworkProfile_STATUS() to populate field NetworkProfile")
}
destination.NetworkProfile = &networkProfile
} else {
destination.NetworkProfile = nil
}
// NodeResourceGroup
destination.NodeResourceGroup = genruntime.ClonePointerToString(cluster.NodeResourceGroup)
// OidcIssuerProfile
if propertyBag.Contains("OidcIssuerProfile") {
var oidcIssuerProfile storage.ManagedClusterOIDCIssuerProfile_STATUS
err := propertyBag.Pull("OidcIssuerProfile", &oidcIssuerProfile)
if err != nil {
return eris.Wrap(err, "pulling 'OidcIssuerProfile' from propertyBag")
}
destination.OidcIssuerProfile = &oidcIssuerProfile
} else {
destination.OidcIssuerProfile = nil
}
// PodIdentityProfile
if cluster.PodIdentityProfile != nil {
var podIdentityProfile storage.ManagedClusterPodIdentityProfile_STATUS
err := cluster.PodIdentityProfile.AssignProperties_To_ManagedClusterPodIdentityProfile_STATUS(&podIdentityProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterPodIdentityProfile_STATUS() to populate field PodIdentityProfile")
}
destination.PodIdentityProfile = &podIdentityProfile
} else {
destination.PodIdentityProfile = nil
}
// PowerState
if cluster.PowerState != nil {
var powerState storage.PowerState_STATUS
err := cluster.PowerState.AssignProperties_To_PowerState_STATUS(&powerState)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_PowerState_STATUS() to populate field PowerState")
}
destination.PowerState = &powerState
} else {
destination.PowerState = nil
}
// PrivateFQDN
destination.PrivateFQDN = genruntime.ClonePointerToString(cluster.PrivateFQDN)
// PrivateLinkResources
if cluster.PrivateLinkResources != nil {
privateLinkResourceList := make([]storage.PrivateLinkResource_STATUS, len(cluster.PrivateLinkResources))
for privateLinkResourceIndex, privateLinkResourceItem := range cluster.PrivateLinkResources {
// Shadow the loop variable to avoid aliasing
privateLinkResourceItem := privateLinkResourceItem
var privateLinkResource storage.PrivateLinkResource_STATUS
err := privateLinkResourceItem.AssignProperties_To_PrivateLinkResource_STATUS(&privateLinkResource)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_PrivateLinkResource_STATUS() to populate field PrivateLinkResources")
}
privateLinkResourceList[privateLinkResourceIndex] = privateLinkResource
}
destination.PrivateLinkResources = privateLinkResourceList
} else {
destination.PrivateLinkResources = nil
}
// ProvisioningState
destination.ProvisioningState = genruntime.ClonePointerToString(cluster.ProvisioningState)
// PublicNetworkAccess
if propertyBag.Contains("PublicNetworkAccess") {
var publicNetworkAccess string
err := propertyBag.Pull("PublicNetworkAccess", &publicNetworkAccess)
if err != nil {
return eris.Wrap(err, "pulling 'PublicNetworkAccess' from propertyBag")
}
destination.PublicNetworkAccess = &publicNetworkAccess
} else {
destination.PublicNetworkAccess = nil
}
// SecurityProfile
if propertyBag.Contains("SecurityProfile") {
var securityProfile storage.ManagedClusterSecurityProfile_STATUS
err := propertyBag.Pull("SecurityProfile", &securityProfile)
if err != nil {
return eris.Wrap(err, "pulling 'SecurityProfile' from propertyBag")
}
destination.SecurityProfile = &securityProfile
} else {
destination.SecurityProfile = nil
}
// ServicePrincipalProfile
if cluster.ServicePrincipalProfile != nil {
var servicePrincipalProfile storage.ManagedClusterServicePrincipalProfile_STATUS
err := cluster.ServicePrincipalProfile.AssignProperties_To_ManagedClusterServicePrincipalProfile_STATUS(&servicePrincipalProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterServicePrincipalProfile_STATUS() to populate field ServicePrincipalProfile")
}
destination.ServicePrincipalProfile = &servicePrincipalProfile
} else {
destination.ServicePrincipalProfile = nil
}
// Sku
if cluster.Sku != nil {
var sku storage.ManagedClusterSKU_STATUS
err := cluster.Sku.AssignProperties_To_ManagedClusterSKU_STATUS(&sku)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterSKU_STATUS() to populate field Sku")
}
destination.Sku = &sku
} else {
destination.Sku = nil
}
// StorageProfile
if propertyBag.Contains("StorageProfile") {
var storageProfile storage.ManagedClusterStorageProfile_STATUS
err := propertyBag.Pull("StorageProfile", &storageProfile)
if err != nil {
return eris.Wrap(err, "pulling 'StorageProfile' from propertyBag")
}
destination.StorageProfile = &storageProfile
} else {
destination.StorageProfile = nil
}
// SystemData
if propertyBag.Contains("SystemData") {
var systemDatum storage.SystemData_STATUS
err := propertyBag.Pull("SystemData", &systemDatum)
if err != nil {
return eris.Wrap(err, "pulling 'SystemData' from propertyBag")
}
destination.SystemData = &systemDatum
} else {
destination.SystemData = nil
}
// Tags
destination.Tags = genruntime.CloneMapOfStringToString(cluster.Tags)
// Type
destination.Type = genruntime.ClonePointerToString(cluster.Type)
// WindowsProfile
if cluster.WindowsProfile != nil {
var windowsProfile storage.ManagedClusterWindowsProfile_STATUS
err := cluster.WindowsProfile.AssignProperties_To_ManagedClusterWindowsProfile_STATUS(&windowsProfile)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedClusterWindowsProfile_STATUS() to populate field WindowsProfile")
}
destination.WindowsProfile = &windowsProfile
} else {
destination.WindowsProfile = nil
}
// WorkloadAutoScalerProfile
if propertyBag.Contains("WorkloadAutoScalerProfile") {
var workloadAutoScalerProfile storage.ManagedClusterWorkloadAutoScalerProfile_STATUS
err := propertyBag.Pull("WorkloadAutoScalerProfile", &workloadAutoScalerProfile)
if err != nil {
return eris.Wrap(err, "pulling 'WorkloadAutoScalerProfile' from propertyBag")
}
destination.WorkloadAutoScalerProfile = &workloadAutoScalerProfile
} else {
destination.WorkloadAutoScalerProfile = nil
}
// Update the property bag
if len(propertyBag) > 0 {
destination.PropertyBag = propertyBag
} else {
destination.PropertyBag = nil
}
// Invoke the augmentConversionForManagedCluster_STATUS interface (if implemented) to customize the conversion
var clusterAsAny any = cluster
if augmentedCluster, ok := clusterAsAny.(augmentConversionForManagedCluster_STATUS); ok {
err := augmentedCluster.AssignPropertiesTo(destination)
if err != nil {
return eris.Wrap(err, "calling augmented AssignPropertiesTo() for conversion")
}
}
// No error
return nil
}