def loadSettings(self):
self.settingsFile = AppSettings()
self.settings = Settings(
self.settingsFile
) # load settings from conf file (create conf file first if necessary)
self.originalSettings = Settings(
self.settingsFile
) # save the original state so that we can know if something has changed when we exit SPARTA
self.logic.setStoreWordlistsOnExit(
self.settings.brute_store_cleartext_passwords_on_exit == 'True')
def load_repositories(self):
from app.domain.products import ProductRepository
if Settings().PRODUCT_REPOSITORY_BACKEND == "sql":
'''example: some sql adapter code'''
elif Settings().PRODUCT_REPOSITORY_BACKEND == "file":
'''example: some file adapter code'''
else:
from app.adapters.products import InMemoryProductRepository
self.product_repository: ProductRepository = self.install_repository(
InMemoryProductRepository(), )
def on_download(self, item=None, files_filter=None, path=None):
path = path or self.check_dest_path()
if not path:
return
settings = Settings(self._settings.settings)
settings.picons_local_path = path + "/"
self.run_func(
lambda: download_data(settings=settings,
download_type=DownloadType.PICONS,
callback=self.append_output,
files_filter=files_filter), True)
def test_load_full_settings_from_file(self, full_settings_file_name):
settings = Settings.load_from_file(full_settings_file_name)
assert settings.cassandra_log_keyspace == "test_logger"
assert settings.cassandra_log_table == "test_log"
assert settings.cassandra_id_column_name == "test_id"
assert settings.cassandra_timestamp_column_name == "test_timestamp"
assert settings.interval_between_runs == 60
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)
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)
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)
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)
def test_load_full_settings_from_file(self, full_settings_file_name):
settings = Settings.load_from_file(full_settings_file_name)
assert settings.cassandra_log_keyspace == "test_logger"
assert settings.cassandra_log_table == "test_log"
assert settings.cassandra_id_column_name == "test_id"
assert settings.cassandra_timestamp_column_name == "test_timestamp"
assert settings.interval_between_runs == 60
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)
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)
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)
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)
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)
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)
def test_load_defaults_if_settings_from_file_is_empty(self, empty_settings_file_name):
settings = Settings.load_from_file(empty_settings_file_name)
assert settings.cassandra_log_keyspace == app.settings.DEFAULT_CASSANDRA_LOG_KEYSPACE
assert settings.cassandra_log_table == app.settings.DEFAULT_CASSANDRA_LOG_TABLE
assert settings.cassandra_id_column_name == app.settings.DEFAULT_CASSANDRA_ID_COLUMN_NAME
assert settings.cassandra_timestamp_column_name == app.settings.DEFAULT_CASSANDRA_TIMESTAMP_COLUMN_NAME
assert settings.interval_between_runs == app.settings.DEFAULT_INTERVAL_BETWEEN_RUNS
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)
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)
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)
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)
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)
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)
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)
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)
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)
def main():
configure_logging()
raw_settings = read_config_file()
settings = Settings(raw_settings)
api = Api(settings.token)
domain = api.get_domain(settings.domain_name)
ip = get_ip()
to_update = None
for entry in domain:
if entry['type'] == 'A' and entry[
'name'] == settings.domain_record_name:
to_update = entry
if ip is None:
return
if to_update is None:
result = api.create_domain(settings.domain_name,
settings.domain_record_name, ip)
_LOGGER.info('Created record for %s with value %s',
settings.domain_record_name, ip)
elif to_update['data'] != ip:
result = api.update_domain(settings.domain_name, to_update['id'], ip)
_LOGGER.info('Updated record for %s with value %s',
settings.domain_record_name, ip)
else:
_LOGGER.info('Ip has not changed, no update needed.')
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)
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)
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)
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)
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)
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)
def __init__(self, settings=None):
if settings:
self._settings = settings
else:
self._settings = Settings.load_from_file(_DEFAULT_SETTINGS_FILE_NAME)
def settings(current_directory):
settings_file = os.path.join(current_directory, "..", "settings.test.yaml")
return Settings.load_from_file(settings_file)
