Backup Operations

class BackupsOperations:
    def trigger(
        self,
        resource_group_name: str,
        vault_name: str,
        fabric_name: str,
        container_name: str,
        protected_item_name: str,
        parameters: BackupRequestResource,
        **kwargs
    ) -> None:
        """
        Trigger an on-demand backup for a protected item.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - fabric_name: Fabric name (usually "Azure")
        - container_name: Container hosting the protected item
        - protected_item_name: Name of the protected item
        - parameters: Backup request configuration
        - kwargs: Additional options

        Returns:
        None (operation is asynchronous - monitor via job operations)
        """

from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupRequestResource,
    IaasVMBackupRequest
)

# Trigger VM backup
backup_request = BackupRequestResource(
    properties=IaasVMBackupRequest(
        recovery_point_expiry_time_in_utc=datetime.utcnow() + timedelta(days=30)
    )
)

client.backups.trigger(
    resource_group_name="my-rg",
    vault_name="my-vault", 
    fabric_name="Azure",
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
    parameters=backup_request
)

print("Backup operation triggered successfully")

class BackupJobsOperations:
    def list(self, resource_group_name: str, vault_name: str, **kwargs) -> Iterable[JobResource]:
        """
        List backup jobs in a Recovery Services vault.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - kwargs: Filter options (status, operation, start_time, end_time, etc.)

        Returns:
        Iterable of JobResource objects
        """

    def get(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> JobResource:
        """
        Get details of a specific backup job.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - job_name: Name/ID of the backup job
        - kwargs: Additional options

        Returns:
        JobResource with detailed job information
        """

    def cancel(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> None:
        """
        Cancel a running backup job.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - job_name: Name/ID of the job to cancel
        - kwargs: Additional options
        """

    def export(self, resource_group_name: str, vault_name: str, **kwargs) -> None:
        """
        Export backup jobs to a storage account.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - kwargs: Export options (storage account, filters, etc.)
        """

# List recent backup jobs
from datetime import datetime, timedelta

end_time = datetime.utcnow()
start_time = end_time - timedelta(days=7)

jobs = client.backup_jobs.list(
    "my-rg", "my-vault",
    filter=f"startTime eq '{start_time.isoformat()}' and endTime eq '{end_time.isoformat()}'"
)

for job in jobs:
    print(f"Job: {job.name}, Status: {job.properties.status}, Operation: {job.properties.operation}")

# Get specific job details
job_details = client.backup_jobs.get("my-rg", "my-vault", "job-id-12345")
print(f"Job Status: {job_details.properties.status}")
print(f"Start Time: {job_details.properties.start_time}")
print(f"End Time: {job_details.properties.end_time}")

# Cancel a running job
client.backup_jobs.cancel("my-rg", "my-vault", "job-id-12345")

class JobsOperations:
    def list(self, resource_group_name: str, vault_name: str, **kwargs) -> Iterable[JobResource]:
        """List jobs with advanced filtering and pagination."""

    def get(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> JobResource:
        """Get job with comprehensive details."""

    def cancel(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> None:
        """Cancel job with validation."""

    def export(self, resource_group_name: str, vault_name: str, **kwargs) -> None:
        """Export jobs with custom parameters."""

class JobDetailsOperations:
    def get(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> JobResource:
        """Get detailed job information including sub-tasks and progress."""

class JobOperationResultsOperations:
    def get(self, resource_group_name: str, vault_name: str, job_name: str, operation_id: str, **kwargs) -> None:
        """Get result of job operation."""

class JobCancellationsOperations:
    def trigger(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> None:
        """Trigger job cancellation with tracking."""

class ExportJobsOperationResultsOperations:
    def get(self, resource_group_name: str, vault_name: str, operation_id: str, **kwargs) -> OperationResultInfoBaseResource:
        """Get result of job export operation."""

class BackupStatusOperations:
    def get(self, azure_region: str, parameters: BackupStatusRequest, **kwargs) -> BackupStatusResponse:
        """
        Get backup status for a resource.

        Parameters:
        - azure_region: Azure region name
        - parameters: Backup status request with resource details
        - kwargs: Additional options

        Returns:
        BackupStatusResponse with protection information
        """

from azure.mgmt.recoveryservicesbackup.activestamp.models import BackupStatusRequest

# Check backup status for a VM
status_request = BackupStatusRequest(
    resource_type="VM",
    resource_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm",
    po_query_type="BackupStatus"
)

backup_status = client.backup_status.get("eastus", status_request)
print(f"Protection Status: {backup_status.protection_info.protection_status}")
print(f"Policy Name: {backup_status.protection_info.policy_name}")

class IaasVMBackupRequest:
    def __init__(
        self,
        recovery_point_expiry_time_in_utc: Optional[datetime] = None,
        **kwargs
    ):
        """
        IaaS VM backup request.

        Parameters:
        - recovery_point_expiry_time_in_utc: Expiration time for the recovery point
        """

    recovery_point_expiry_time_in_utc: Optional[datetime]

class AzureFileShareBackupRequest:
    def __init__(
        self,
        recovery_point_expiry_time_in_utc: Optional[datetime] = None,
        **kwargs
    ):
        """
        Azure file share backup request.

        Parameters:
        - recovery_point_expiry_time_in_utc: Expiration time for the recovery point
        """

    recovery_point_expiry_time_in_utc: Optional[datetime]

class AzureWorkloadBackupRequest:
    def __init__(
        self,
        backup_type: Optional[str] = None,
        enable_compression: Optional[bool] = None,
        recovery_point_expiry_time_in_utc: Optional[datetime] = None,
        **kwargs
    ):
        """
        Azure workload backup request.

        Parameters:
        - backup_type: Type of backup ("Full", "Differential", "Log", "CopyOnlyFull")
        - enable_compression: Whether to enable backup compression
        - recovery_point_expiry_time_in_utc: Expiration time for the recovery point
        """

    backup_type: Optional[str]
    enable_compression: Optional[bool]
    recovery_point_expiry_time_in_utc: Optional[datetime]

class AzureIaaSVMJob:
    def __init__(
        self,
        entity_friendly_name: Optional[str] = None,
        backup_management_type: str = "AzureIaasVM",
        operation: Optional[str] = None,
        status: Optional[str] = None,
        start_time: Optional[datetime] = None,
        end_time: Optional[datetime] = None,
        activity_id: Optional[str] = None,
        duration: Optional[str] = None,
        actions_info: Optional[List[str]] = None,
        error_details: Optional[List[AzureIaaSVMErrorInfo]] = None,
        virtual_machine_version: Optional[str] = None,
        extended_info: Optional[AzureIasSVMJobExtendedInfo] = None,
        **kwargs
    ):
        """
        Azure IaaS VM backup job.

        Parameters:
        - entity_friendly_name: Display name of the VM
        - backup_management_type: Always "AzureIaasVM" 
        - operation: Operation type ("Backup", "Restore", "ConfigureBackup", etc.)
        - status: Job status ("InProgress", "Completed", "Failed", etc.)
        - start_time: Job start time
        - end_time: Job end time (if completed)
        - activity_id: Unique activity identifier
        - duration: Job execution duration
        - actions_info: Available actions for the job
        - error_details: Error information if job failed
        - virtual_machine_version: VM version information
        - extended_info: Additional job details
        """

    entity_friendly_name: Optional[str]
    backup_management_type: str
    operation: Optional[str]
    status: Optional[str]
    start_time: Optional[datetime]
    end_time: Optional[datetime]
    activity_id: Optional[str]
    duration: Optional[str]
    actions_info: Optional[List[str]]
    error_details: Optional[List[AzureIaaSVMErrorInfo]]
    virtual_machine_version: Optional[str]
    extended_info: Optional[AzureIasSVMJobExtendedInfo]

class AzureStorageJob:
    def __init__(
        self,
        entity_friendly_name: Optional[str] = None,
        backup_management_type: str = "AzureStorage",
        operation: Optional[str] = None,
        status: Optional[str] = None,
        start_time: Optional[datetime] = None,
        end_time: Optional[datetime] = None,
        activity_id: Optional[str] = None,
        duration: Optional[str] = None,
        actions_info: Optional[List[str]] = None,
        error_details: Optional[List[AzureStorageErrorInfo]] = None,
        storage_account_name: Optional[str] = None,
        storage_account_version: Optional[str] = None,
        extended_info: Optional[AzureStorageJobExtendedInfo] = None,
        **kwargs
    ):
        """
        Azure Storage (file share) backup job.

        Parameters:
        - entity_friendly_name: Display name of the file share
        - backup_management_type: Always "AzureStorage"
        - operation: Operation type ("Backup", "Restore", "ConfigureBackup", etc.)
        - status: Job status
        - start_time: Job start time
        - end_time: Job end time (if completed)
        - activity_id: Unique activity identifier
        - duration: Job execution duration
        - actions_info: Available actions for the job
        - error_details: Error information if job failed
        - storage_account_name: Name of the storage account
        - storage_account_version: Storage account version
        - extended_info: Additional job details
        """

    entity_friendly_name: Optional[str]
    backup_management_type: str
    operation: Optional[str]
    status: Optional[str]
    start_time: Optional[datetime]
    end_time: Optional[datetime]
    activity_id: Optional[str]
    duration: Optional[str]
    actions_info: Optional[List[str]]
    error_details: Optional[List[AzureStorageErrorInfo]]
    storage_account_name: Optional[str]
    storage_account_version: Optional[str]
    extended_info: Optional[AzureStorageJobExtendedInfo]

class AzureWorkloadJob:
    def __init__(
        self,
        entity_friendly_name: Optional[str] = None,
        backup_management_type: str = "AzureWorkload",
        operation: Optional[str] = None,
        status: Optional[str] = None,
        start_time: Optional[datetime] = None,
        end_time: Optional[datetime] = None,
        activity_id: Optional[str] = None,
        duration: Optional[str] = None,
        actions_info: Optional[List[str]] = None,
        error_details: Optional[List[AzureWorkloadErrorInfo]] = None,
        workload_type: Optional[str] = None,
        extended_info: Optional[AzureWorkloadJobExtendedInfo] = None,
        **kwargs
    ):
        """
        Azure workload backup job.

        Parameters:
        - entity_friendly_name: Display name of the workload
        - backup_management_type: Always "AzureWorkload"
        - operation: Operation type ("Backup", "Restore", "ConfigureBackup", etc.)
        - status: Job status
        - start_time: Job start time
        - end_time: Job end time (if completed)
        - activity_id: Unique activity identifier
        - duration: Job execution duration
        - actions_info: Available actions for the job
        - error_details: Error information if job failed
        - workload_type: Type of workload ("SQLDataBase", "SAPHanaDatabase", etc.)
        - extended_info: Additional job details
        """

    entity_friendly_name: Optional[str]
    backup_management_type: str
    operation: Optional[str]
    status: Optional[str]
    start_time: Optional[datetime]
    end_time: Optional[datetime]
    activity_id: Optional[str]
    duration: Optional[str]
    actions_info: Optional[List[str]]
    error_details: Optional[List[AzureWorkloadErrorInfo]]
    workload_type: Optional[str]
    extended_info: Optional[AzureWorkloadJobExtendedInfo]

from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupRequestResource,
    IaasVMBackupRequest
)
from datetime import datetime, timedelta

# Trigger immediate backup with 30-day retention
backup_request = BackupRequestResource(
    properties=IaasVMBackupRequest(
        recovery_point_expiry_time_in_utc=datetime.utcnow() + timedelta(days=30)
    )
)

client.backups.trigger(
    resource_group_name="my-rg",
    vault_name="my-vault",
    fabric_name="Azure", 
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
    parameters=backup_request
)

# List active backup jobs
active_jobs = client.backup_jobs.list(
    "my-rg", "my-vault",
    filter="status eq 'InProgress'"
)

for job in active_jobs:
    print(f"Job: {job.name}")
    print(f"Operation: {job.properties.operation}")
    print(f"Status: {job.properties.status}")
    print(f"Start Time: {job.properties.start_time}")
    
    # Get detailed job information
    job_details = client.job_details.get("my-rg", "my-vault", job.name)
    if hasattr(job_details.properties, 'extended_info'):
        print(f"Progress: {job_details.properties.extended_info.progress_percentage}%")

from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupRequestResource,
    AzureWorkloadBackupRequest
)

# Trigger SQL database full backup
sql_backup_request = BackupRequestResource(
    properties=AzureWorkloadBackupRequest(
        backup_type="Full",
        enable_compression=True,
        recovery_point_expiry_time_in_utc=datetime.utcnow() + timedelta(days=90)
    )
)

client.backups.trigger(
    resource_group_name="my-rg",
    vault_name="my-vault",
    fabric_name="Azure",
    container_name="vmappcontainer;compute;vm-rg;sql-vm",
    protected_item_name="sqldatabase;mssqlserver;sqldb01",
    parameters=sql_backup_request
)

# Export jobs to storage account for analysis
client.backup_jobs.export(
    resource_group_name="my-rg",
    vault_name="my-vault",
    # Export parameters would be in the request body
    container_uri="https://mystorageaccount.blob.core.windows.net/backupjobs",
    sas_token="?sv=2021-06-08&ss=b&srt=sco&sp=rwdlacupx&se=...",
    start_time=datetime.utcnow() - timedelta(days=30),
    end_time=datetime.utcnow()
)