Connected Registries

def begin_create(resource_group_name: str, registry_name: str, connected_registry_name: str, connected_registry_create_parameters: ConnectedRegistry, **kwargs) -> LROPoller[ConnectedRegistry]:
    """
    Create a connected registry for a container registry.
    
    Parameters:
    - resource_group_name: str - Name of the resource group
    - registry_name: str - Name of the parent registry
    - connected_registry_name: str - Name of the connected registry
    - connected_registry_create_parameters: ConnectedRegistry - Connected registry configuration
    
    Returns:
    LROPoller[ConnectedRegistry] - Long-running operation poller for the connected registry
    """

def begin_delete(resource_group_name: str, registry_name: str, connected_registry_name: str, **kwargs) -> LROPoller[None]:
    """
    Delete a connected registry from a container registry.
    
    Parameters:
    - resource_group_name: str - Name of the resource group
    - registry_name: str - Name of the parent registry
    - connected_registry_name: str - Name of the connected registry to delete
    
    Returns:
    LROPoller[None] - Long-running operation poller
    """

def begin_update(resource_group_name: str, registry_name: str, connected_registry_name: str, connected_registry_update_parameters: ConnectedRegistryUpdateParameters, **kwargs) -> LROPoller[ConnectedRegistry]:
    """
    Update a connected registry for a container registry.
    
    Parameters:
    - resource_group_name: str - Name of the resource group
    - registry_name: str - Name of the parent registry
    - connected_registry_name: str - Name of the connected registry to update
    - connected_registry_update_parameters: ConnectedRegistryUpdateParameters - Update parameters
    
    Returns:
    LROPoller[ConnectedRegistry] - Long-running operation poller for the updated connected registry
    """

def get(resource_group_name: str, registry_name: str, connected_registry_name: str, **kwargs) -> ConnectedRegistry:
    """
    Get properties of a connected registry.
    
    Parameters:
    - resource_group_name: str - Name of the resource group
    - registry_name: str - Name of the parent registry
    - connected_registry_name: str - Name of the connected registry
    
    Returns:
    ConnectedRegistry - Connected registry resource with complete configuration
    """

def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[ConnectedRegistry]:
    """
    List all connected registries for a container registry.
    
    Parameters:
    - resource_group_name: str - Name of the resource group
    - registry_name: str - Name of the parent registry
    
    Returns:
    ItemPaged[ConnectedRegistry] - Paginated list of all connected registries
    """

def begin_deactivate(resource_group_name: str, registry_name: str, connected_registry_name: str, **kwargs) -> LROPoller[None]:
    """
    Deactivate a connected registry from a container registry.
    
    Parameters:
    - resource_group_name: str - Name of the resource group
    - registry_name: str - Name of the parent registry
    - connected_registry_name: str - Name of the connected registry to deactivate
    
    Returns:
    LROPoller[None] - Long-running operation poller for deactivation
    """

class ConnectedRegistry:
    """
    An object that represents a connected registry for a container registry.
    
    Attributes:
    - id: str - Resource ID
    - name: str - Resource name
    - type: str - Resource type
    - provisioning_state: ProvisioningState - Current provisioning state
    - mode: ConnectedRegistryMode - Connected registry mode (ReadWrite, ReadOnly, Registry, Mirror)
    - version: str - Connected registry version
    - connection_state: ConnectionState - Current connection state
    - last_activity_time: datetime - Last activity timestamp
    - activation: ActivationProperties - Activation configuration
    - parent: ParentProperties - Parent registry configuration
    - client_token_ids: List[str] - Client token IDs for authentication
    - login_server: LoginServerProperties - Login server configuration
    - logging: LoggingProperties - Logging configuration
    - status_details: List[StatusDetailProperties] - Detailed status information
    - notifications_list: List[str] - Notification configurations
    """

class ConnectedRegistryUpdateParameters:
    """
    Parameters for updating a connected registry.
    
    Attributes:
    - sync_properties: SyncProperties - Synchronization properties
    - logging: LoggingProperties - Logging configuration
    - client_token_ids: List[str] - Client token IDs
    - notifications_list: List[str] - Notification configurations
    """

class ActivationProperties:
    """
    Properties for connected registry activation.
    
    Attributes:
    - status: ActivationStatus - Activation status (Active, Inactive)
    """

class LoginServerProperties:
    """
    Login server properties for connected registry.
    
    Attributes:
    - host: str - Login server host
    - tls: TlsProperties - TLS configuration
    """

class TlsProperties:
    """
    TLS configuration properties.
    
    Attributes:
    - status: TlsStatus - TLS status (Enabled, Disabled)
    - certificate_type: CertificateType - Certificate type
    """

class LoggingProperties:
    """
    Logging properties for connected registry.
    
    Attributes:
    - log_level: LogLevel - Log level (Debug, Information, Warning, Error, None)
    - audit_log_status: AuditLogStatus - Audit log status (Enabled, Disabled)
    """

class SyncProperties:
    """
    Synchronization properties for connected registry.
    
    Attributes:
    - token_id: str - Token ID for synchronization
    - schedule: str - Synchronization schedule
    - sync_window: str - Synchronization window
    - message_ttl: str - Message time-to-live
    - gateway_endpoint: str - Gateway endpoint for synchronization
    """

class ParentProperties:
    """
    Parent registry properties for connected registry.
    
    Attributes:
    - id: str - Parent registry resource ID
    - sync_properties: SyncProperties - Synchronization configuration with parent
    """

class ConnectedRegistryMode(str, Enum):
    """Connected registry operational modes."""
    READ_WRITE = "ReadWrite"
    READ_ONLY = "ReadOnly"
    REGISTRY = "Registry"
    MIRROR = "Mirror"

class ConnectionState(str, Enum):
    """Connected registry connection states."""
    ONLINE = "Online"
    OFFLINE = "Offline"
    SYNCING = "Syncing"
    UNHEALTHY = "Unhealthy"

class ActivationStatus(str, Enum):
    """Connected registry activation status."""
    ACTIVE = "Active"
    INACTIVE = "Inactive"

class LogLevel(str, Enum):
    """Logging levels for connected registry."""
    DEBUG = "Debug"
    INFORMATION = "Information"
    WARNING = "Warning"
    ERROR = "Error"
    NONE = "None"

class AuditLogStatus(str, Enum):
    """Audit log status options."""
    ENABLED = "Enabled"
    DISABLED = "Disabled"

class TlsStatus(str, Enum):
    """TLS status options."""
    ENABLED = "Enabled"
    DISABLED = "Disabled"

class CertificateType(str, Enum):
    """Certificate type options."""
    LOCAL_DIRECTORY = "LocalDirectory"

from azure.mgmt.containerregistry import ContainerRegistryManagementClient
from azure.mgmt.containerregistry.models import (
    ConnectedRegistry, ConnectedRegistryMode, ActivationProperties, ActivationStatus,
    LoginServerProperties, TlsProperties, TlsStatus, CertificateType,
    LoggingProperties, LogLevel, AuditLogStatus, SyncProperties
)
from azure.identity import DefaultAzureCredential

client = ContainerRegistryManagementClient(
    DefaultAzureCredential(), 
    "subscription-id"
)

# Create a connected registry for edge deployment
connected_registry_params = ConnectedRegistry(
    mode=ConnectedRegistryMode.READ_WRITE,
    activation=ActivationProperties(
        status=ActivationStatus.ACTIVE
    ),
    client_token_ids=[
        "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ContainerRegistry/registries/parent-registry/tokens/edge-token"
    ],
    login_server=LoginServerProperties(
        host="edge-registry.local",
        tls=TlsProperties(
            status=TlsStatus.ENABLED,
            certificate_type=CertificateType.LOCAL_DIRECTORY
        )
    ),
    logging=LoggingProperties(
        log_level=LogLevel.INFORMATION,
        audit_log_status=AuditLogStatus.ENABLED
    ),
    parent=ParentProperties(
        sync_properties=SyncProperties(
            token_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ContainerRegistry/registries/parent-registry/tokens/sync-token",
            schedule="0 9 * * *",  # Daily at 9 AM
            sync_window="PT1H",    # 1 hour sync window
            message_ttl="P1D"      # 1 day message TTL
        )
    ),
    notifications_list=["webhook1", "webhook2"]
)

# Create the connected registry
creation_poller = client.connected_registries.begin_create(
    "my-resource-group",
    "my-parent-registry",
    "edge-registry",
    connected_registry_params
)

connected_registry = creation_poller.result()
print(f"Created connected registry: {connected_registry.name}")
print(f"Mode: {connected_registry.mode}")
print(f"Connection State: {connected_registry.connection_state}")

# Create a read-only connected registry for performance optimization
readonly_registry_params = ConnectedRegistry(
    mode=ConnectedRegistryMode.READ_ONLY,
    activation=ActivationProperties(
        status=ActivationStatus.ACTIVE
    ),
    client_token_ids=[
        "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ContainerRegistry/registries/parent-registry/tokens/readonly-token"
    ],
    login_server=LoginServerProperties(
        host="cache-registry.local",
        tls=TlsProperties(
            status=TlsStatus.ENABLED,
            certificate_type=CertificateType.LOCAL_DIRECTORY
        )
    ),
    logging=LoggingProperties(
        log_level=LogLevel.WARNING,  # Less verbose logging
        audit_log_status=AuditLogStatus.DISABLED
    ),
    parent=ParentProperties(
        sync_properties=SyncProperties(
            token_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ContainerRegistry/registries/parent-registry/tokens/sync-token",
            schedule="0 */6 * * *",  # Every 6 hours
            sync_window="PT30M",     # 30 minute sync window
            message_ttl="PT12H"      # 12 hour message TTL
        )
    )
)

readonly_registry = client.connected_registries.begin_create(
    "my-resource-group",
    "my-parent-registry",
    "cache-registry",
    readonly_registry_params
).result()

print(f"Created read-only connected registry: {readonly_registry.name}")

# List all connected registries and monitor their status
connected_registries = client.connected_registries.list(
    "my-resource-group",
    "my-parent-registry"
)

print("Connected Registries Status:")
print("-" * 50)
for registry in connected_registries:
    print(f"Registry: {registry.name}")
    print(f"  Mode: {registry.mode}")
    print(f"  Connection State: {registry.connection_state}")
    print(f"  Provisioning State: {registry.provisioning_state}")
    print(f"  Last Activity: {registry.last_activity_time}")
    print(f"  Activation Status: {registry.activation.status}")
    print(f"  Login Server: {registry.login_server.host}")
    print(f"  Log Level: {registry.logging.log_level}")
    
    if registry.status_details:
        print("  Status Details:")
        for detail in registry.status_details:
            print(f"    - {detail}")
    print()

from azure.mgmt.containerregistry.models import ConnectedRegistryUpdateParameters

# Update sync properties and logging configuration
update_params = ConnectedRegistryUpdateParameters(
    sync_properties=SyncProperties(
        schedule="0 */4 * * *",  # Every 4 hours instead of 6
        sync_window="PT45M",     # Longer sync window
        message_ttl="P2D"        # Longer message TTL
    ),
    logging=LoggingProperties(
        log_level=LogLevel.DEBUG,  # More verbose logging
        audit_log_status=AuditLogStatus.ENABLED
    ),
    notifications_list=["webhook1", "webhook2", "webhook3"]  # Add notification
)

updated_registry = client.connected_registries.begin_update(
    "my-resource-group",
    "my-parent-registry",
    "cache-registry",
    update_params
).result()

print(f"Updated connected registry: {updated_registry.name}")
print(f"New sync schedule: {updated_registry.parent.sync_properties.schedule}")

def manage_connected_registry_lifecycle(client, resource_group, parent_registry, connected_registry_name, action):
    """
    Manage connected registry lifecycle operations.
    """
    
    if action == "deactivate":
        # Deactivate connected registry
        print(f"Deactivating connected registry: {connected_registry_name}")
        deactivation_poller = client.connected_registries.begin_deactivate(
            resource_group,
            parent_registry,
            connected_registry_name
        )
        deactivation_poller.result()
        print("Connected registry deactivated")
        
    elif action == "reactivate":
        # Reactivate by updating activation status
        update_params = ConnectedRegistryUpdateParameters(
            activation=ActivationProperties(
                status=ActivationStatus.ACTIVE
            )
        )
        
        reactivation_poller = client.connected_registries.begin_update(
            resource_group,
            parent_registry,
            connected_registry_name,
            update_params
        )
        reactivated_registry = reactivation_poller.result()
        print(f"Connected registry reactivated: {reactivated_registry.activation.status}")
        
    elif action == "delete":
        # Delete connected registry
        print(f"Deleting connected registry: {connected_registry_name}")
        deletion_poller = client.connected_registries.begin_delete(
            resource_group,
            parent_registry,
            connected_registry_name
        )
        deletion_poller.result()
        print("Connected registry deleted")

# Example usage
manage_connected_registry_lifecycle(
    client,
    "my-resource-group",
    "my-parent-registry",
    "cache-registry",
    "deactivate"
)

# Set up connected registries for multiple edge sites
edge_sites = [
    {
        "name": "factory-east",
        "host": "registry.factory-east.local",
        "mode": ConnectedRegistryMode.READ_WRITE,
        "sync_schedule": "0 8 * * *",  # 8 AM daily
        "log_level": LogLevel.INFORMATION
    },
    {
        "name": "factory-west",
        "host": "registry.factory-west.local", 
        "mode": ConnectedRegistryMode.READ_WRITE,
        "sync_schedule": "0 20 * * *",  # 8 PM daily
        "log_level": LogLevel.INFORMATION
    },
    {
        "name": "warehouse-cache",
        "host": "registry.warehouse.local",
        "mode": ConnectedRegistryMode.READ_ONLY,
        "sync_schedule": "0 */12 * * *",  # Every 12 hours
        "log_level": LogLevel.WARNING
    }
]

created_registries = []

for site in edge_sites:
    registry_params = ConnectedRegistry(
        mode=site["mode"],
        activation=ActivationProperties(status=ActivationStatus.ACTIVE),
        client_token_ids=[
            f"/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ContainerRegistry/registries/parent-registry/tokens/{site['name']}-token"
        ],
        login_server=LoginServerProperties(
            host=site["host"],
            tls=TlsProperties(
                status=TlsStatus.ENABLED,
                certificate_type=CertificateType.LOCAL_DIRECTORY
            )
        ),
        logging=LoggingProperties(
            log_level=site["log_level"],
            audit_log_status=AuditLogStatus.ENABLED if site["mode"] == ConnectedRegistryMode.READ_WRITE else AuditLogStatus.DISABLED
        ),
        parent=ParentProperties(
            sync_properties=SyncProperties(
                token_id=f"/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ContainerRegistry/registries/parent-registry/tokens/{site['name']}-sync-token",
                schedule=site["sync_schedule"],
                sync_window="PT1H",
                message_ttl="P1D"
            )
        )
    )
    
    registry = client.connected_registries.begin_create(
        "my-resource-group",
        "my-parent-registry",
        site["name"],
        registry_params
    ).result()
    
    created_registries.append(registry)
    print(f"Created connected registry for {site['name']}: {registry.login_server.host}")

print(f"\nTotal connected registries created: {len(created_registries)}")

# Monitor all connected registries
print("\nConnected Registry Health Check:")
print("=" * 50)
for registry in created_registries:
    health_status = "Healthy" if registry.connection_state == ConnectionState.ONLINE else "Unhealthy"
    print(f"{registry.name}: {health_status} ({registry.connection_state})")

def diagnose_connected_registry(client, resource_group, parent_registry, connected_registry_name):
    """
    Diagnose issues with a connected registry.
    """
    
    # Get connected registry details
    registry = client.connected_registries.get(
        resource_group,
        parent_registry,
        connected_registry_name
    )
    
    diagnosis = {
        "registry_name": registry.name,
        "issues": [],
        "recommendations": []
    }
    
    # Check connection state
    if registry.connection_state != ConnectionState.ONLINE:
        diagnosis["issues"].append(f"Connection state is {registry.connection_state}")
        if registry.connection_state == ConnectionState.OFFLINE:
            diagnosis["recommendations"].append("Check network connectivity and firewall rules")
        elif registry.connection_state == ConnectionState.UNHEALTHY:
            diagnosis["recommendations"].append("Check connected registry logs and system health")
    
    # Check activation status
    if registry.activation.status != ActivationStatus.ACTIVE:
        diagnosis["issues"].append(f"Registry is not active: {registry.activation.status}")
        diagnosis["recommendations"].append("Activate the connected registry")
    
    # Check provisioning state
    if registry.provisioning_state != ProvisioningState.SUCCEEDED:
        diagnosis["issues"].append(f"Provisioning state: {registry.provisioning_state}")
        diagnosis["recommendations"].append("Check provisioning logs and retry if failed")
    
    # Check last activity time
    if registry.last_activity_time:
        import datetime
        time_since_activity = datetime.datetime.utcnow() - registry.last_activity_time
        if time_since_activity.total_seconds() > 86400:  # 24 hours
            diagnosis["issues"].append(f"No activity for {time_since_activity}")
            diagnosis["recommendations"].append("Check synchronization configuration and network connectivity")
    
    # Check status details for specific errors
    if registry.status_details:
        for detail in registry.status_details:
            if "error" in detail.lower() or "fail" in detail.lower():
                diagnosis["issues"].append(f"Status detail: {detail}")
                diagnosis["recommendations"].append("Review detailed error messages and correct configuration")
    
    return diagnosis

# Diagnose a problematic connected registry
diagnosis = diagnose_connected_registry(
    client,
    "my-resource-group",
    "my-parent-registry",
    "problematic-registry"
)

print("Connected Registry Diagnosis:")
print("=" * 40)
print(f"Registry: {diagnosis['registry_name']}")

if diagnosis["issues"]:
    print("\nIssues Found:")
    for issue in diagnosis["issues"]:
        print(f"  - {issue}")
    
    print("\nRecommendations:")
    for rec in diagnosis["recommendations"]:
        print(f"  - {rec}")
else:
    print("\nNo issues detected - registry appears healthy")