Exemplo n.º 1
0
async def sr_vdis(cluster_id: str, sr_uuid: str):
    """Get VDIs by SR"""

    from API.v1.VDI.serialize import serialize as _vdi_serialize

    try:
        session = create_session(cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        sr: SR = SR.get_by_uuid(session=session, uuid=sr_uuid)

        vdis = sr.get_VDIs()
        if vdis is not None:
            vdis = await asyncio.gather(*[_vdi_serialize(vdi) for vdi in vdis])
        else:
            pass

        if sr is not None:
            ret = dict(success=True, data=vdis)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 2
0
async def vdi_get_by_uuid(cluster_id: str, vdi_uuid: str):
    """ Delete SR by UUID """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters()
            )
        except KeyError as key_error:
            raise HTTPException(
                status_code=400, detail=f"{key_error} is not a valid path"
            )

        vdi: VDI = VDI.get_by_uuid(session=session, uuid=vdi_uuid)

        if vdi is not None:
            ret = dict(success=vdi.destroy())
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 3
0
async def find_VDI_by_name(cluster_id: str, args: NameArgs):
    """Find VDI by Name"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        name = args.name
        vdis = VDI.get_by_name(session=session, name=name)

        if vdis is not None:
            __vdis_list = []
            for vdi in vdis:
                __vdis_list.append(await serialize(vdi))

            ret = dict(success=True, data=__vdis_list)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 4
0
async def vm_list(cluster_id: str):
    """ Gets VMs available on Xen Server """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        vms = VM.list_vm(session=session)

        __sat = []
        sat = __sat.append
        for vm in vms:
            sat(serialize(vm))

        ret = dict(success=True, data=__sat)
        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 5
0
async def instance_clone(cluster_id: str, vm_uuid: str, args: CloneArgs):
    """Clone Instance (VM/Template)"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        _vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)
        new_vm = await _vm.clone(args.name)

        if new_vm is not None:
            if args.provision:
                await new_vm.provision()

            new_vm_uuid = new_vm.get_uuid()

            ret = Response(
                "",
                status_code=302,
                headers={"Location": f"/v1/{cluster_id}/vm/{new_vm_uuid}"},
            )
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 6
0
async def vif_list(cluster_id: str):
    """ Get All from Storage Repos """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters()
            )
        except KeyError as key_error:
            raise HTTPException(
                status_code=400, detail=f"{key_error} is not a valid path"
            )

        vifs = VIF.get_all(session=session)

        __santilized_vifs = []
        santilized_vifs = __santilized_vifs.append
        for vif in vifs:
            santilized_vifs(serialize(vif))

        ret = dict(success=True, data=__santilized_vifs)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 7
0
async def vif_get_by_uuid(cluster_id: str, vif_uuid: str):
    """Get VIF by UUID"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vif: VIF = VIF.get_by_uuid(session=session, uuid=vif_uuid)

        if vif is not None:
            ret = dict(success=True, data=await serialize(vif))
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 8
0
async def vif_set_ipv6_by_uuid(
    cluster_id: str, vif_uuid: str, addresses: IPAddressesModel
):
    """Set VIF IPv6 by UUID"""
    try:
        session = create_session(
            _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters()
        )

        vif: VIF = VIF.get_by_uuid(session=session, uuid=vif_uuid)
        vif.set_allowed_address_v6(addresses.addresses)

        ret = dict(
            success=True,
        )

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(
            status_code=500, detail=xenapi_failure_jsonify(xenapi_error)
        )
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 9
0
async def vbd_list(cluster_id: str, vdi_uuid: str):
    """ Get VBD by UUID """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        vbds = VBD.get_all(session=session)

        __vbd_list = []
        _vbd_list = __vbd_list.append
        for vbd in vbds:
            if vbd.get_VDI().get_uuid() == vdi_uuid:
                _vbd_list(serialize(vbd))

        if vbds is not None:
            ret = dict(success=True, data=__vbd_list)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 10
0
async def instance_set_platform_property_byname_inurl(
    cluster_id: str, vm_uuid: str, name: str, var: str
):
    """ Set Instance (VM/Template) Platform Property by Name """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters()
            )
        except KeyError as key_error:
            raise HTTPException(
                status_code=400, detail=f"{key_error} is not a valid path"
            )

        vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)

        if vm is not None:
            data = {name: var}

            ret = dict(success=vm.set_platform(data))
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 11
0
async def sr_scan(cluster_id: str, sr_uuid: str):
    """ Scan Storage Repository """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        sr: SR = SR.get_by_uuid(session=session, uuid=sr_uuid)

        if sr is not None:
            sr.scan()
            ret = dict(success=True)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 12
0
async def get_cd_eject(cluster_id: str, vm_uuid: str):
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)

        if vm is not None:

            new_vbd = vm.get_CD()

            if new_vbd is not None:
                success = new_vbd.eject()

                ret = dict(success=success)
            else:
                ret = dict(success=False)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 13
0
async def instance_set_name(cluster_id: str, vm_uuid: str, args: NameArgs):
    """ Set Instance (VM/Template) Name """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        _vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)
        if _vm is not None:
            ret = dict(success=_vm.set_name(args.name))
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 14
0
async def guest_get_by_uuid(
    cluster_id: str = Path(default=None,
                           title="cluster_id",
                           description="Cluster ID"),
    guest_uuid: str = Path(default=None,
                           title="guest_uuid",
                           description="Guest UUID"),
):
    """ Get GuestMetrics by UUID """
    try:
        # KeyError Handling
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        guest: GuestMetrics = Host.get_by_uuid(session=session,
                                               uuid=guest_uuid)

        if guest is not None:
            ret = dict(success=True, data=serialize(guest))
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 15
0
async def pif_list(cluster_id: str):
    """Get All PIF from cluster"""

    try:
        session = create_session(
            _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters()
        )

        pifs = PIF.get_all(session=session)
        __santilized_pifs = await asyncio.gather(*[serialize(pif) for pif in pifs])

        ret = dict(success=True, data=__santilized_pifs)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(
            status_code=500, detail=xenapi_failure_jsonify(xenapi_error)
        )
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 16
0
async def vm_console(cluster_id: str, vm_uuid: str, url_after: str = ""):
    """Get the first console of the VM"""

    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)
        consoles: Console = vm.get_consoles()

        if len(consoles) == 0:
            raise HTTPException(
                status_code=404,
                detail=f"Console doesn't exist on VM {vm_uuid}",
            )

        console: Console = consoles[0]
        console_uuid = console.get_uuid()

        return RedirectResponse(
            url=f"/v1/{cluster_id}/console/{console_uuid}{url_after}")
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 17
0
async def vdi_list(cluster_id: str):
    """Get VDI by UUID"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vdis = VDI.get_all(session=session)
        __vdi_list = await asyncio.gather(*[serialize(vdi) for vdi in vdis])

        if vdis is not None:
            ret = dict(success=True, data=__vdi_list)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 18
0
async def vm_consoles(cluster_id: str, vm_uuid: str):
    """Get all consoles are available to the VM"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)
        consoles = vm.get_consoles()

        __consoleList = []
        for console in consoles:
            __consoleList.append(_console_serialize(console))

        ret = dict(success=True, data=__consoleList)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 19
0
async def vm_guest(cluster_id: str, vm_uuid: str):
    """ Get VM Guest Info """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)
        if vm is not None:
            ret = dict(success=True,
                       data=_guest_serialize(vm.get_guest_metrics()))
        else:
            session.xenapi.session.logout()
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 20
0
async def host_list(cluster_id: str = Path(default=None,
                                           title="cluster_id",
                                           description="Cluster ID")):
    """Get All from Existance Host"""
    try:
        session = create_session(cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        hosts = Host.list_host(session=session)

        __hosts_list = await asyncio.gather(
            *[serialize(host) for host in hosts])

        ret = dict(success=True, data=__hosts_list)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 21
0
async def vif_get_qos_speed_by_uuid(cluster_id: str, vif_uuid: str):
    """ Set VIF QoS Type by UUID """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters()
            )
        except KeyError as key_error:
            raise HTTPException(
                status_code=400, detail=f"{key_error} is not a valid path"
            )
        vif: VIF = VIF.get_by_uuid(session=session, uuid=vif_uuid)

        if vif is not None:
            ret = dict(success=True, data=vif.get_qos_info()["kbps"])
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 22
0
async def instance_clone_inurl(cluster_id: str, vm_uuid: str, clone_name: str):
    """ Clone Instance (VM/Template) """
    try:
        new_vm = None
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        _vm: VM = VM.get_by_uuid(session, vm_uuid)
        if _vm is not None:
            new_vm = _vm.clone(clone_name)
            if new_vm is not None:
                ret = dict(success=True, data=serialize(new_vm))
            else:
                ret = dict(success=False)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 23
0
async def instance_vif(cluster_id: str, vm_uuid: str):
    """ Show Instnace VIFs """
    try:
        try:
            session = create_session(
                _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters())
        except KeyError as key_error:
            raise HTTPException(status_code=400,
                                detail=f"{key_error} is not a valid path")

        vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)

        if vm is not None:

            new_vif = vm.get_VIF()

            if new_vif is not None:

                ret = dict(success=True, data=_vif_serialize(new_vif))
            else:
                ret = dict(success=False)
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 24
0
async def console_get_by_uuid(
    cluster_id: str,
    console_uuid: str,
):
    """Get Console by UUID"""
    try:
        pass

        session = create_session(
            cluster_id, get_xen_clusters=Settings.get_xen_clusters()
        )

        console: Console = Console.get_by_uuid(session, console_uuid)

        if console is not None:
            ret = dict(success=True, data=await serialize(console))
        else:
            ret = dict(success=False)

        return ret
    except Failure as xenapi_error:
        raise HTTPException(
            status_code=500, detail=xenapi_failure_jsonify(xenapi_error)
        )
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 25
0
async def template_list(cluster_id: str):
    """Gets Templates available on Xen Server"""
    try:
        session = create_session(
            _id=cluster_id, get_xen_clusters=Settings.get_xen_clusters()
        )

        vms = VM.list_templates(session=session)

        __sat = []
        for vm in vms:
            __sat.append(await serialize(vm))

        ret = dict(success=True, data=__sat)
        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(
            status_code=500, detail=xenapi_failure_jsonify(xenapi_error)
        )
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 26
0
async def host_get_by_uuid(
    cluster_id: str = Path(default=None,
                           title="cluster_id",
                           description="Cluster ID"),
    host_uuid: str = Path(default=None,
                          title="host_uuid",
                          description="Host UUID"),
):
    """Get Host by UUID"""
    try:
        session = create_session(cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        host: Host = Host.get_by_uuid(session=session, uuid=host_uuid)

        if host is not None:
            ret = dict(success=True, data=await serialize(host))
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 27
0
async def _vbd_plug(cluster_id: str, vbd_uuid: str):
    """Plug VBD into VM"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vbd: VBD = VBD.get_by_uuid(session=session, uuid=vbd_uuid)

        if vbd is not None:
            ret = dict(success=vbd.plug())
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 28
0
async def vif_get_qos_type_by_uuid(cluster_id: str, vif_uuid: str,
                                   data: QoSTypeArgs):
    """Set VIF QoS Data by UUID"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vif: VIF = VIF.get_by_uuid(session=session, uuid=vif_uuid)

        result = True
        if data.type is not None:
            vif.set_qos_type(data.type)

        if data.info is not None:
            vif.set_qos_info(data.info)

        ret = dict(success=True, data=result)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 29
0
async def vif_get_ipv4_by_uuid(cluster_id: str, vif_uuid: str):
    """Get VIF IPv4 by UUID"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vif: VIF = VIF.get_by_uuid(session=session, uuid=vif_uuid)
        ret = dict(
            success=True,
            data=dict(
                address=vif.get_address_v4(),
                gateway=vif.get_gateway_v4(),
            ),
        )

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)
Exemplo n.º 30
0
async def instance_info(cluster_id: str, vm_uuid: str):
    """Get an Info of VM or Template"""
    try:
        session = create_session(_id=cluster_id,
                                 get_xen_clusters=Settings.get_xen_clusters())

        vm: VM = VM.get_by_uuid(session=session, uuid=vm_uuid)

        if vm is not None:
            ret = dict(success=True, data=await serialize(vm))
        else:
            ret = dict(success=False)

        session.xenapi.session.logout()
        return ret
    except Failure as xenapi_error:
        raise HTTPException(status_code=500,
                            detail=xenapi_failure_jsonify(xenapi_error))
    except Fault as xml_rpc_error:
        raise HTTPException(
            status_code=int(xml_rpc_error.faultCode),
            detail=xml_rpc_error.faultString,
        )
    except RemoteDisconnected as rd_error:
        raise HTTPException(status_code=500, detail=rd_error.strerror)