如何正确将LDAP DN数据嵌套到Python字典中？

原始代码 #

class ldapDict():
    jsonStruct={}

def add_keys_nested_dict(d, keys):
    if len(keys) == 1:
        d.setdefault(keys[0], 1)
    else:
        key = keys[0]
        if key not in d:
            d[key] = {}
        add_keys_nested_dict(d[key], keys[1:])

def listSplit(input):
    dnList=input.split(',')
    res = [i for i in dnList if i not in ldapSearchBase.split(',')]
    if(len(res)<=1):
        primaryKey=ldapSearchBase
        parent=ldapSearchBase
    else:
        primaryKey=res[0]
        parent=res[1]
    return (parent,primaryKey)

def dissectList(input):
    x=listSplit(input)
    add_keys_nested_dict(ldapDict.jsonStruct,x)

问题描述 #

上述代码用于解析LDAP的DN数据并构建嵌套字典，但输出未按正确父节点层级嵌套：

{
  "dc=ZZ,dc=org": {
    "dc=ZZ,dc=org": 1
  },
  "dc=dows": {
    "ou=users": 1,
    "ou=userunit": 1,
    "ou=unittypemaster": 1
  },
  "ou=unittypemaster": {
    "accessunittypemasterkey=A": 1,
    "accessunittypemasterkey=B": 1,
    "accessunittypemasterkey=C": 1,
    "accessunittypemasterkey=D": 1,
    "accessunittypemasterkey=E": 1,
    "accessunittypemasterkey=F": 1
  }, ...
}

dc=ZZ,dc=org是根节点，但dc=dows未嵌套于其下，ou=unittypemaster也未嵌套到dc=dows的对应位置，需要实现正确的字典嵌套结构。

问题根源 #

1. listSplit函数仅提取DN中的前两个非根节点部分，未保留完整层级路径，无法构建多层嵌套。
2. LDAP DN的顺序是叶子节点在前、根节点在后（如ou=unittypemaster,dc=dows,dc=ZZ,dc=org），未反转路径就构建嵌套，导致层级逻辑颠倒。

修复后的代码 #

class ldapDict():
    jsonStruct = {}

def add_keys_nested_dict(d, keys):
    current = d
    # 遍历完整路径，逐层创建嵌套字典
    for key in keys[:-1]:
        if key not in current:
            current[key] = {}
        current = current[key]
    # 最后一个节点设为标识值1
    current.setdefault(keys[-1], 1)

def listSplit(input_dn, base_dn):
    # 拆分DN和基准根节点为组件列表
    dn_components = input_dn.split(',')
    base_components = base_dn.split(',')
    # 反转DN组件，得到从根到叶子的顺序
    reversed_dn = dn_components[::-1]
    # 提取完整的层级组件列表（从根节点到当前叶子节点）
    full_path_components = reversed_dn
    # 拼接成每个层级的完整节点名称（如"dc=ZZ,dc=org"、"dc=ZZ,dc=org,dc=dows"）
    full_path_names = []
    for i in range(1, len(full_path_components)+1):
        full_path_names.append(','.join(full_path_components[:i]))
    return full_path_names

def dissectList(input_dn):
    global ldapSearchBase
    path_keys = listSplit(input_dn, ldapSearchBase)
    add_keys_nested_dict(ldapDict.jsonStruct, path_keys)

代码说明 #

1. listSplit函数修改：
   • 反转DN组件顺序，将叶子在前的DN转为根在前的层级路径。
   • 拼接每个层级的完整节点名称，确保嵌套时能正确关联父节点。
2. add_keys_nested_dict函数修改：
   • 遍历完整路径列表，逐层创建嵌套字典，最后为叶子节点设置标识值。
3. 使用示例：

   ldapSearchBase = "dc=ZZ,dc=org"
   # 测试解析多个DN
   dissectList("accessunittypemasterkey=A,ou=unittypemaster,dc=dows,dc=ZZ,dc=org")
   dissectList("ou=users,dc=dows,dc=ZZ,dc=org")
   
   # 打印格式化后的嵌套字典
   import json
   print(json.dumps(ldapDict.jsonStruct, indent=2))
   

   输出的正确嵌套结构：

   {
     "dc=ZZ,dc=org": {
       "dc=ZZ,dc=org,dc=dows": {
         "dc=ZZ,dc=org,dc=dows,ou=unittypemaster": {
           "dc=ZZ,dc=org,dc=dows,ou=unittypemaster,accessunittypemasterkey=A": 1
         },
         "dc=ZZ,dc=org,dc=dows,ou=users": 1
       }
     }
   }
   

   若希望节点名称仅保留当前层级组件（如dc=dows而非完整路径），可修改listSplit返回full_path_components（单个组件列表），输出会变为：

   {
     "dc=ZZ": {
       "dc=org": {
         "dc=dows": {
           "ou=unittypemaster": {
             "accessunittypemasterkey=A": 1
           },
           "ou=users": 1
         }
       }
     }
   }
   

   可根据实际需求选择对应逻辑。

内容的提问来源于stack exchange，提问作者Carl