Create a Child Prefix in Custom Script Without Using the API

[paulcarre07]

Hello Everyone,

I’m working on a task to create a child prefix of a specified length from an existing prefix. I’ve managed to accomplish this using the API with the following Python script:

import requests

url = "NETBOX_URL"
headers = {
    "Authorization": "Token YOUR_API_TOKEN",
    "Content-Type": "application/json"
}
data = {
    "prefix_length": 31
}

response = requests.post(url, headers=headers, json=data)

if response.status_code == 201:
    print("Available prefix created:", response.json())
else:
    print("Failed to create prefix:", response.status_code, response.text)

While this works fine, I’m looking for a way to achieve the same result directly within a NetBox custom script, without relying on API calls.

Does anyone have insights or examples of how to perform this directly through Script? Any advice or solutions would be greatly appreciated!

[jsenecal]

Have you looked at other custom scripts to build your own ?
https://github.com/netbox-community/customizations/tree/master/scripts

You can use the netbox (django) models directly in the custom scripts and leverage all the availlable methods.

[paulcarre07]

Here’s what I’m currently using in my custom script to allocate a child prefix:

    def allocate_interco_prefix(self, device, prefix_length, wan_interface, commit):
        """
        Allocate an interconnection prefix from the available pool
        Searches for available space in prefixes tagged with 'inter-co'
        Returns: Created Prefix object or None if allocation fails
        """
        prefix_length = int(prefix_length)
        self.log_info(f"Allocating interco prefix with /{prefix_length}...")
        parent_prefixes = Prefix.objects.filter(tags__slug='inter-co')
        prefix_created = False

        for parent_prefix in parent_prefixes:
            if parent_prefix.mask_length < prefix_length:
                available_prefixes = sorted(
                    parent_prefix.get_available_prefixes().iter_cidrs(),
                    key=lambda p: p.prefixlen,
                    reverse=True
                )

                for available_prefix in available_prefixes:
                    subnets = list(IPNetwork(available_prefix).subnet(prefix_length))

                    for child_prefix in subnets:
                        if child_prefix[-1] != 255:
                            self.log_info(f"Attempting to create /{prefix_length} prefix: {child_prefix} (dry-run)")

                            if commit:
                                try:
                                    created_prefix = Prefix.objects.create(
                                        prefix=child_prefix,
                                        status='active',
                                        description=f"Auto-created interco prefix from {parent_prefix}",
                                        site=parent_prefix.site,
                                        tenant=parent_prefix.tenant,
                                        vrf=parent_prefix.vrf,
                                        tags=parent_prefix.tags.all(),
                                    )
                                    utilization = created_prefix.get_utilization()
                                    if utilization == 0:
                                        self.log_success(f"Created new interco /{prefix_length} prefix: {created_prefix}")
                                        prefix_created = True

                                        if wan_interface:
                                            self.assign_ip_to_wan_interface(wan_interface, created_prefix, commit)
                                        else:
                                            self.log_info("No WAN interface found on the device.")

                                        interco_prefix = list(IPNetwork(created_prefix.prefix))
                                        self.log_info(f"All IPs within the prefix {created_prefix.prefix}: {interco_prefix}")
                                        
                                        break
                                    else:
                                        created_prefix.delete()
                                        self.log_info(f"Created prefix {created_prefix} had utilization; deleted and continuing.")
                                except Exception as e:
                                    self.log_failure(f"Failed to create prefix {child_prefix}: {e}")
                        else:
                            self.log_info(f"Skipping {child_prefix} as it covers the broadcast IP.")

                    if prefix_created:
                        break

            if prefix_created:
                break

        if not prefix_created:
            self.log_info(f"No suitable /{prefix_length} interco prefix found.")
        
        return created_prefix

This script works, but the API offers the POST method to create child prefixes, which is more straightforward and concise. This makes me wonder:

• Is there a better way to handle this directly within a custom script, perhaps leveraging similar functionality as the API POST method?
• Are there built-in methods or Django model functions in NetBox that could simplify or enhance my script?

[candlerb]

You didn't show which REST API endpoint you are invoking, but I'm guessing it's a POST to /api/ipam/prefixes/<id>/available-prefixes/.

If so, then the URL is matched here. The implementation is a bit tricky because it's quite general to support allocation of various types of objects; you should look at AvailablePrefixesView here, AvailableObjectsView here, which calls back to get_available_objects and prep_object_data.

In short, I think what it's doing is creating an IPSet to represent the unallocated space, calling ipam.utils.get_next_available_prefix to allocate a prefix of the requested size from that space, and then creating a Prefix object.

[paulcarre07]

Thank you for your response! You’re absolutely correct; the REST API endpoint I’m invoking is indeed /api/ipam/prefixes//available-prefixes/.

I’ve looked at the implementation of AvailablePrefixesView and get_next_available_prefix that you mentioned, and they seem to handle the logic quite efficiently. This is why I’m wondering if there’s a way to leverage other similar functionality directly in my custom script to simplify my code.

    def allocate_interco_prefix(self, device, prefix_length, wan_interface, commit):
        """
        Allocate an interconnection prefix from the available pool
        Searches for available space in prefixes tagged with 'inter-co'
        Returns: Created Prefix object or None if allocation fails
        """
        prefix_length = int(prefix_length)
        self.log_info(f"Allocating interco prefix with /{prefix_length}...")
        parent_prefixes = Prefix.objects.filter(tags__slug='inter-co')
        prefix_created = False

        for parent_prefix in parent_prefixes:
            if parent_prefix.mask_length < prefix_length:
                available_prefixes = sorted(
                    parent_prefix.get_available_prefixes().iter_cidrs(),
                    key=lambda p: p.prefixlen,
                    reverse=True
                )

                for available_prefix in available_prefixes:
                    subnets = list(IPNetwork(available_prefix).subnet(prefix_length))

                    for child_prefix in subnets:
                        if child_prefix[-1] != 255:
                            self.log_info(f"Attempting to create /{prefix_length} prefix: {child_prefix} (dry-run)")

                            if commit:
                                try:
                                    created_prefix = Prefix.objects.create(
                                        prefix=child_prefix,
                                        status='active',
                                        description=f"Auto-created interco prefix from {parent_prefix}",
                                        site=parent_prefix.site,
                                        tenant=parent_prefix.tenant,
                                        vrf=parent_prefix.vrf,
                                        tags=parent_prefix.tags.all(),
                                    )
                                    utilization = created_prefix.get_utilization()
                                    if utilization == 0:
                                        self.log_success(f"Created new interco /{prefix_length} prefix: {created_prefix}")
                                        prefix_created = True

                                        if wan_interface:
                                            self.assign_ip_to_wan_interface(wan_interface, created_prefix, commit)
                                        else:
                                            self.log_info("No WAN interface found on the device.")

                                        interco_prefix = list(IPNetwork(created_prefix.prefix))
                                        self.log_info(f"All IPs within the prefix {created_prefix.prefix}: {interco_prefix}")
                                        
                                        break
                                    else:
                                        created_prefix.delete()
                                        self.log_info(f"Created prefix {created_prefix} had utilization; deleted and continuing.")
                                except Exception as e:
                                    self.log_failure(f"Failed to create prefix {child_prefix}: {e}")
                        else:
                            self.log_info(f"Skipping {child_prefix} as it covers the broadcast IP.")

                    if prefix_created:
                        break

            if prefix_created:
                break

        if not prefix_created:
            self.log_info(f"No suitable /{prefix_length} interco prefix found.")
        
        return created_prefix

Here’s the main point I’m curious about:

Since the API uses get_next_available_prefix and other utility methods, is there a better way to access these directly from my custom script?
If so, could you point me to an example or provide guidance on how I might replicate the same logic in a script without having to reimplement what’s already done by the API?

Currently, my custom script works (shared above), but it feels verbose compared to how cleanly the API handles this. I’d like to improve it if possible.

[candlerb]

get_next_available_prefix can be imported from ipam.utils, like the view does. Although there's no guarantee this won't change in future versions of Netbox, there are no stability guarantees for any part of the Netbox API anyway, so you might as well use it.

You can't easily invoke the View logic directly, so you'd best replicate it. I don't think there is any common logic that you could import, because if there were, the View logic would use it too.

[paulcarre07]

I’ll proceed by importing get_next_available_prefix from ipam.utils and replicating the relevant logic as you suggested.

However, if I’m not mistaken, get_next_available_prefix might not guarantee that the returned prefix will have the desired length. It seems to simply allocate the next available prefix, which could have a different length. If this is the case, I may need additional checks to ensure the prefix length matches the one I’m requesting.

Does that sound correct, or am I missing something?

[candlerb]

It looks fine to me.

get_next_available_prefix takes a desired prefix size as an argument. It iterates over the available space, finds the first chunk with prefix length less than or equal to the prefix length requested, and then returns the lowest chunk of that space within it.

For example, if you ask for /30, it will skip over any /31 or /32 available areas. But if the next available area is a /26, it will return the first /30 within that /26.

That's not optimal, because if there were an exact /30 later on it could have returned that to avoid fragmenting the address space unnecessarily. But it will allocate a chunk of the requested size.

IMO, a better algorithm would be to sort the available cidr blocks by descending order of prefix size.

[paulcarre07]

Got it, thanks for the clarification! I now see that while get_next_available_prefix works, it's not the most optimal solution, especially in terms of minimizing address space fragmentation. I’ll look into refining the process and find a more efficient way to allocate the prefixes.

Thanks again for all your help!