updates to resource pool qualifiers

Author: scotttyso

defaults.yaml

@@ -23,7 +23,18 @@ locals {
   } }
   org_keys  = sort(keys(var.model))
   org_names = merge({ for k, v in var.orgs : v => k }, jsondecode("{\"5ddfd9ff6972652d31ee6582\":\"x_cisco_intersight_internal\"}"))
+  policy_defaults = yamldecode(file("${path.module}/defaults.yaml")).policies
+  policies_model  = { for org in local.org_keys : org => lookup(var.model[org], "policies", {}) }
+  policy_names    = ["server_pool_qualification"]
   pool_type = ["ip", "iqn", "mac", "resource", "uuid", "wwnn", "wwpn"]
+  ppfx = { for org in keys(var.orgs) : org => {
+    for e in local.policy_names : e => lookup(lookup(lookup(lookup(var.model, org, {}), "policies", {}), "name_prefix", {}
+    ), e, lookup(lookup(lookup(lookup(var.model, org, {}), "policies", {}), "name_prefix", local.policy_defaults.name_prefix), "default", ""))
+  } }
+  psfx = { for org in keys(var.orgs) : org => {
+    for e in local.policy_names : e => lookup(lookup(lookup(lookup(var.model, org, {}), "policies", {}), "name_suffix", {}
+    ), e, lookup(lookup(lookup(lookup(var.model, org, {}), "policies", {}), "name_suffix", local.policy_defaults.name_suffix), "default", ""))
+  } }
 
   #____________________________________________________________
   #
@@ -120,6 +131,127 @@ locals {
     wwpn = { for v in sort(keys(intersight_fcpool_reservation.wwpn)) : v => intersight_fcpool_reservation.wwpn[v].moid }
   }
 
+  #____________________________________________________________
+  #
+  # Intersight Server Pool Qualification Policy
+  # GUI Location: Policies > Create Policy: Server Pool Qualification
+  #____________________________________________________________
+  qka  = { AdaptersRange = "number_of_network_adapters" }
+  qkb  = { AssetTags = "asset_tags", ChassisPids = "chassis_pids", Pids = "blade_pids", UserLabels = "user_labels" }
+  qkd  = { DomainNames = "domain_names", FabricInterConnectPids = "fabric_interconnect_pids" }
+  qkc  = { CPUCoresRange = "number_of_cores", SpeedRange = "speed" }
+  qkg  = { GpuControllersRange = "number_of_gpus" }
+  qkm  = { MemoryCapacityRange = "capacity", MemoryUnitsRange = "number_of_units" }
+  qko  = { CPUCoresRange = "resource.CPUCoreRangeFilter", SpeedRange = "resource.CpuSpeedRangeFilter" }
+  qkr  = { AssetTags = "asset_tags", Pids = "rack_pids", UserLabels = "user_labels" }
+  qkt  = { ChassisTags = "chassis_tags", DomainProfileTags = "domain_profile_tags", ServerTags = "server_tags" }
+  spq  = local.policy_defaults.server_pool_qualification
+  spqt = ["adapter", "blade_server", "cpu", "domain", "gpu", "memory", "rack_server", "tag_qualifier"]
+  server_pool_qualification = { for i in flatten([for org in local.org_keys : [
+    for v in lookup(local.policies_model[org], "server_pool_qualification", []) : {
+      adapter = length(lookup(lookup(v, "hardware_qualifiers", {}), "network_adapter", {})) > 0 ? {
+        additional_properties = jsonencode({ for a, b in local.qka : a => {
+          ConditionType = "RANGE"
+          MaxValue      = lookup(lookup(v.hardware_qualifiers.network_adapter, b, {}), "maximum", 0)
+          MinValue      = lookup(lookup(v.hardware_qualifiers.network_adapter, b, {}), "minimum", 0)
+          ObjectType    = "${a}Filter"
+        } })
+        class_id    = "resource.NetworkAdaptorQualifier"
+        object_type = "resource.NetworkAdaptorQualifier"
+      } : {}
+      blade_server = length(lookup(lookup(v, "server_qualifiers", {}), "blade_server", {})) > 0 ? {
+        additional_properties = jsonencode(merge({ for a, b in local.qkb : a => lookup(v.server_qualifiers.blade_server, b, []) },
+          { ChassisAndSlotIdRange = [for e in lookup(v.server_qualifiers.blade_server, "chassis_slot_qualifier", []) : {
+            ChassisIdRange = {
+              ClassId       = "resource.ChassisIdRangeFilter"
+              ConditionType = "RANGE"
+              MaxValue      = e.chassis_ids.to
+              MinValue      = e.chassis_ids.from
+              ObjectType    = "resource.ChassisIdRangeFilter"
+            }
+            ObjectType = "resource.ChassisAndSlotQualification"
+            SlotIdRanges = [for d in lookup(e, "slot_ids", []) : {
+              ClassId       = "resource.SlotIdRangeFilter"
+              ConditionType = "RANGE"
+              MaxValue      = d.to
+              MinValue      = d.from
+              ObjectType    = "resource.SlotIdRangeFilter"
+            }]
+        }] }))
+        class_id    = "resource.BladeQualifier"
+        object_type = "resource.BladeQualifier"
+      } : {}
+      cpu = length(lookup(lookup(v, "hardware_qualifiers", {}), "cpu", {})) > 0 ? {
+        additional_properties = jsonencode(merge({ for a, b in local.qkc : a => {
+          ConditionType = "RANGE"
+          MaxValue      = lookup(lookup(v.hardware_qualifiers.cpu, b, {}), "maximum", 0)
+          MinValue      = lookup(lookup(v.hardware_qualifiers.cpu, b, {}), "minimum", 0)
+          ObjectType    = local.qko[a]
+          } }, {
+          Pids   = lookup(v.hardware_qualifiers.cpu, "pids", [])
+          Vendor = lookup(v.hardware_qualifiers.cpu, "vendor", "")
+        }))
+        class_id    = "resource.ProcessorQualifier"
+        object_type = "resource.ProcessorQualifier"
+      } : {}
+      description = lookup(v, "description", "")
+      domain = length(lookup(v, "domain_qualifiers", {})) > 0 ? {
+        additional_properties = jsonencode({ for a, b in local.qkd : a => lookup(v.domain_qualifiers, b, []) })
+        class_id              = "resource.DomainQualifier"
+        object_type           = "resource.DomainQualifier"
+      } : {}
+      gpu = {
+        additional_properties = jsonencode(merge({ for a, b in local.qkg : a => {
+          ConditionType = "RANGE"
+          MaxValue      = lookup(lookup(lookup(lookup(v, "hardware_qualifiers", {}), "gpu", {}), b, {}), "maximum", 0)
+          MinValue      = lookup(lookup(lookup(lookup(v, "hardware_qualifiers", {}), "gpu", {}), b, {}), "minimum", 0)
+          ObjectType    = "${a}Filter"
+          } }, {
+          GpuEvaluationType = lookup(lookup(lookup(v, "hardware_qualifiers", {}), "gpu", {}), "evaluation_type", "ServerWithoutGpu")
+          Pids              = lookup(lookup(lookup(v, "hardware_qualifiers", {}), "gpu", {}), "pids", [])
+          Vendor            = lookup(lookup(lookup(v, "hardware_qualifiers", {}), "gpu", {}), "vendor", "")
+        }))
+        class_id    = "resource.GpuQualifier"
+        object_type = "resource.GpuQualifier"
+      }
+      memory = length(lookup(lookup(v, "hardware_qualifiers", {}), "memory", {})) > 0 ? {
+        additional_properties = jsonencode({ for a, b in local.qkm : a => {
+          ConditionType = "RANGE"
+          MaxValue      = lookup(lookup(v.hardware_qualifiers.memory, b, {}), "maximum", 0)
+          MinValue      = lookup(lookup(v.hardware_qualifiers.memory, b, {}), "minimum", 0)
+          ObjectType    = "${a}Filter"
+        } })
+        class_id    = "resource.MemoryQualifier"
+        object_type = "resource.MemoryQualifier"
+      } : {}
+      name = "${local.ppfx[org].server_pool_qualification}${v.name}${local.psfx[org].server_pool_qualification}"
+      org  = org
+      rack_server = length(lookup(lookup(v, "server_qualifiers", {}), "rack_server", {})) > 0 ? {
+        additional_properties = jsonencode(merge({
+          for a, b in local.qkr : a => lookup(v.server_qualifiers.rack_server, b, []) },
+          { RackIdRange = [for e in lookup(v.server_qualifiers.rack_server, "rack_ids", []) : {
+            ConditionType = "RANGE"
+            MaxValue      = e.to
+            MinValue      = e.from
+            ObjectType    = "resource.RackIdRangeFilter"
+          }] }
+        ))
+        class_id    = "resource.RackServerQualifier"
+        object_type = "resource.RackServerQualifier"
+      } : {}
+      tag_qualifier = length(lookup(v, "tag_qualifiers", {})) > 0 ? {
+        additional_properties = jsonencode({
+          for a, b in local.qkt : a => [
+            for e in lookup(v.tag_qualifiers, b, []) : { Key = e.key, ObjectType = "resource.Tag", Value = e.value }
+          ]
+        })
+        class_id    = "resource.TagQualifier"
+        object_type = "resource.TagQualifier"
+      } : {}
+      tags = lookup(v, "tags", local.global_settings.tags)
+    }
+  ] if length(lookup(local.policies_model[org], "server_pool_qualification", [])) > 0]) : "${i.org}/${i.name}" => i }
+
   #____________________________________________________________
   #
   # Intersight Resource Pool

locals.tf

@@ -15,31 +15,41 @@ output "data_pools" {
 
 output "ip" {
   description = "Moids of the IP Pools."
-  value       = { for v in sort(keys(intersight_ippool_pool.map)) : v => intersight_ippool_pool.map[v].moid }
+  value       = { for k, v in intersight_ippool_pool.map : k => v.moid }
 }
 output "iqn" {
   description = "Moids of the IQN Pools."
-  value       = { for v in sort(keys(intersight_iqnpool_pool.map)) : v => intersight_iqnpool_pool.map[v].moid }
+  value       = { for k, v in intersight_iqnpool_pool.map : k => v.moid }
 }
 output "mac" {
   description = "Moids of the MAC Pools."
-  value       = { for v in sort(keys(intersight_macpool_pool.map)) : v => intersight_macpool_pool.map[v].moid }
+  value       = { for k, v in intersight_macpool_pool.map : k => v.moid }
 }
 output "resource" {
   description = "Moids of the Resource Pools."
-  value       = { for v in sort(keys(intersight_resourcepool_pool.map)) : v => intersight_resourcepool_pool.map[v].moid }
+  value       = { for k, v in intersight_resourcepool_pool.map : k => v.moid }
 }
 output "uuid" {
   description = "Moids of the UUID Pools."
-  value       = { for v in sort(keys(intersight_uuidpool_pool.map)) : v => intersight_uuidpool_pool.map[v].moid }
+  value       = { for k, v in intersight_uuidpool_pool.map : k => v.moid }
 }
 output "wwnn" {
   description = "Moids of the WWNN Pools."
-  value       = { for v in sort(keys(intersight_fcpool_pool.wwnn)) : v => intersight_fcpool_pool.wwnn[v].moid }
+  value       = { for k, v in intersight_fcpool_pool.wwnn : k => v.moid }
 }
 output "wwpn" {
   description = "Moids of the WWPN Pools."
-  value       = { for v in sort(keys(intersight_fcpool_pool.wwpn)) : v => intersight_fcpool_pool.wwpn[v].moid }
+  value       = { for k, v in intersight_fcpool_pool.wwpn : k => v.moid }
+}
+
+#__________________________________________________________
+#
+# Server Pool Qualification Policy
+#__________________________________________________________
+
+output "server_pool_qualification" {
+  description = "Moids of the Server Pool Qualfication Policies."
+  value = {for k, v in intersight_resourcepool_qualification_policy.map : k => v.moid }
 }
 
 #__________________________________________________________

outputs.tf

@@ -1,8 +1,14 @@
+#____________________________________________________________
+#
+# Intersight IP Pool Resource
+# GUI Location: Pools > Create Pool
+#____________________________________________________________
+
 resource "intersight_resourcepool_qualification_policy" "map" {
   for_each    = local.server_pool_qualification
   description = each.value.description != "" ? each.value.description : "${each.value.name} Server Pool Qualification."
   name        = each.value.name
-  #organization { moid = var.orgs[each.value.org] }
+  organization { moid = var.orgs[each.value.org] }
   qualifiers = [for e in local.spqt : lookup(each.value, e, {}) if length(lookup(each.value, e, {})) > 0]
   dynamic "tags" {
     for_each = { for v in each.value.tags : v.key => v }