Boot Resources and Sources

client.boot_resources.list()
client.boot_resources.get(id)
client.boot_resources.create(**params)
client.boot_resources.start_import()
client.boot_resources.stop_import()

from maas.client import connect

client = connect('http://maas.example.com:5240/MAAS/', apikey='key')

# List boot resources
resources = client.boot_resources.list()
for resource in resources:
    print(f"{resource.name}: {resource.architecture}")

# Get specific resource
resource = client.boot_resources.get(1)

# Start importing boot resources
client.boot_resources.start_import()

# Stop import
client.boot_resources.stop_import()

class BootResourceSet:
    """A boot resource set (nested within BootResource)."""
    version (str, readonly): Version identifier (e.g., '20220420', build date/time)
    size (int, readonly): Total size of all files in bytes
    label (str, readonly): Label (e.g., 'release', 'daily')
    complete (bool, readonly): Whether all files are fully downloaded
    files (dict[str, BootResourceFile], readonly): Dictionary of files keyed by filename

# Access boot resource sets
resource = client.boot_resources.get(1)
for version, resource_set in resource.sets.items():
    print(f"Version: {version}")
    print(f"  Size: {resource_set.size} bytes")
    print(f"  Label: {resource_set.label}")
    print(f"  Complete: {resource_set.complete}")
    print(f"  Files: {len(resource_set.files)}")

class BootResourceFile:
    """A boot resource file (nested within BootResourceSet)."""
    filename (str, readonly): Filename (e.g., 'boot-kernel', 'boot-initrd', 'root-tgz')
    filetype (str, readonly): File type ('tgz', 'ddtgz', etc.)
    size (int, readonly): File size in bytes
    sha256 (str, readonly): SHA256 checksum of the file
    complete (bool, readonly): Whether file is fully downloaded

# Access boot resource files
resource = client.boot_resources.get(1)
for version, resource_set in resource.sets.items():
    print(f"\nVersion: {version}")
    for filename, rfile in resource_set.files.items():
        print(f"  File: {filename}")
        print(f"    Type: {rfile.filetype}")
        print(f"    Size: {rfile.size} bytes")
        print(f"    SHA256: {rfile.sha256}")
        print(f"    Complete: {rfile.complete}")

import io

# Prepare custom image content
with open('/path/to/custom-image.tgz', 'rb') as f:
    content = io.BytesIO(f.read())

# Upload custom boot resource
resource = await client.boot_resources.create(
    name='custom/image',
    architecture='amd64/generic',
    content=content,
    title='Custom Boot Image',
    filetype=BootResourceFileType.TGZ
)

print(f"Uploaded resource: {resource.name}")
print(f"Resource ID: {resource.id}")

client.boot_sources.list()
client.boot_sources.get(id)
BootSource.read(id)
client.boot_sources.create(url, keyring_filename=None, keyring_data=None)
boot_source.save()
boot_source.delete()

# List boot sources
sources = client.boot_sources.list()

# Get specific source
source = client.boot_sources.get(1)

# Or use BootSource.read()
from maas.client.viscera import BootSource
source = await BootSource.read(1)

# Create custom boot source
source = await client.boot_sources.create(
    url='http://images.maas.io/ephemeral-v3/stable/',
    keyring_filename='/usr/share/keyrings/ubuntu-cloudimage-keyring.gpg'
)

# Create boot source with keyring data
import io
with open('/path/to/keyring.gpg', 'rb') as f:
    keyring_data = f.read()
source = await client.boot_sources.create(
    url='http://custom-mirror.example.com/images/',
    keyring_data=io.BytesIO(keyring_data)
)

# Update boot source
source.url = 'http://updated-mirror.example.com/images/'
await source.save()

# Delete boot source
await source.delete()

BootSourceSelections.read(boot_source)
BootSourceSelections.create(boot_source, os, release, arches=None, subarches=None, labels=None)
BootSourceSelection.read(boot_source, id)
selection.save()
selection.delete()

from maas.client.viscera import BootSourceSelection, BootSourceSelections

# Get boot source
boot_source = client.boot_sources.get(1)

# List selections for boot source
selections = await BootSourceSelections.read(boot_source)
for selection in selections:
    print(f"{selection.os}/{selection.release}: {selection.arches}")

# Get specific selection
selection = await BootSourceSelection.read(boot_source, 1)

# Create selection for Ubuntu 22.04 on amd64
selection = await BootSourceSelections.create(
    boot_source,
    os='ubuntu',
    release='jammy',
    arches=['amd64'],
    subarches=['*'],
    labels=['release']
)

# Create selection with wildcards (import all)
selection = await BootSourceSelections.create(
    boot_source,
    os='*',
    release='*',
    arches=['*'],
    subarches=['*'],
    labels=['*']
)

# Create selection for specific architectures
selection = await BootSourceSelections.create(
    boot_source,
    os='ubuntu',
    release='focal',
    arches=['amd64', 'arm64'],
    subarches=['generic', 'hwe-20.04'],
    labels=['release', 'daily']
)

# Update selection
selection.arches = ['amd64', 'arm64', 'ppc64el']
await selection.save()

# Delete selection
await selection.delete()

# Import only LTS releases for amd64
await BootSourceSelections.create(
    boot_source,
    os='ubuntu',
    release='focal',  # Or 'jammy', 'noble', etc.
    arches=['amd64'],
    subarches=['*'],
    labels=['release']
)

# Import all Ubuntu releases, all architectures
await BootSourceSelections.create(
    boot_source,
    os='ubuntu',
    release='*',
    arches=['*'],
    subarches=['*'],
    labels=['*']
)

# Import specific daily builds for testing
await BootSourceSelections.create(
    boot_source,
    os='ubuntu',
    release='noble',
    arches=['amd64'],
    subarches=['*'],
    labels=['daily']
)