Slice notifications and life cycle

import network_as_code as nac

from network_as_code.models.device import DeviceIpv4Addr

from network_as_code.models.slice import(
    NetworkIdentifier,
    SliceInfo,
)

import asyncio
import time

# We begin by creating a Network as Code client
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# This is the device object we'll later attach to the slice
my_device = client.devices.get(
    "[email protected]",
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
)

# Then, we create a slice
my_slice = client.slices.create(
    name="slice-name",
    network_id = NetworkIdentifier(mcc="236", mnc="30"),
    slice_info = SliceInfo(service_type="eMBB", differentiator="123456"),
    # Use HTTPS to send notifications
    notification_url="http://notify.me/here",
    notification_auth_token="replace-with-your-auth-token"
)

# Alternatively, you can also get a slice by its ID:
slice = client.slices.get(my_slice.name)

async def slice_attachments():
    # We can take advantage of Slice.wait_for() in async functions
    # This allows us to, e.g., wait for a slice to become available
    await my_slice.wait_for(desired_state="AVAILABLE")

    # Slices must be activated before devices can be added
    my_slice.activate()
    await my_slice.wait_for(desired_state="OPERATING")

    # Afterwards we can attach or detach devices
    device = client.devices.get(my_device)
    my_slice.attach(my_device)
    my_slice.detach(my_device)

    # For deallocating a slice, we first deactivate the slice
    my_slice.deactivate()
    await my_slice.wait_for(desired_state="AVAILABLE")

    # A deactivated slice can be freely removed
    my_slice.delete()

# Since we use the asynchronous Slice.wait_for(), we must execute
# in an async function. We can run such functions with asyncio:
asyncio.run(slice_attachments())

# If you cannot run async functions, you can also utilize webhook
# handlers or polling to handle slice state transitions.
# Simple manual polling can be implemented like this:
while my_slice.state != "AVAILABLE":
    my_slice.refresh()
    time.sleep(1)

import time

from fastapi import FastAPI, Header

from pydantic import BaseModel

from typing_extensions import Annotated
from typing import Union

import network_as_code as nac

from network_as_code.models.slice import (
    NetworkIdentifier,
    SliceInfo,
)

# We begin by creating a Network as Code client
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# Then, we create a slice
my_slice = client.slices.create(
    name="slice-name",
    network_id = NetworkIdentifier(mcc="236", mnc="30"),
    slice_info = SliceInfo(service_type="eMBB", differentiator="123456"),
    # Use HTTPS to send notifications
    notification_url="https://example.com/notifications",
    notification_auth_token="replace-with-your-auth-token"
)

# Our web server for receiving notifications

app = FastAPI()

class Notification(BaseModel):
    resource: str
    action: str
    state: str

# We'll keep track of when we are retiring the slice between the notifications
retiring = False

@app.post("/notifications")
def receive_notification(
    notification: Notification,
    authorization: Annotated[Union[str, None], Header]
):
    if authorization == "Bearer my-token":
        # We can now react to the notifications
        # based on the Notification object
        print(notification)