def libvirt_worker_loop(loop, start_websockets_server, hypervisors):
def _err_handler(self, ctxt, err):
print("Error from libvirt : %s", err[2])
print("[{}] entering libvirt_worker_loop".format(
threading.get_ident()))
prctl.set_name('libvirt_loop')
asyncio.set_event_loop(loop)
libvirtaio.virEventRegisterAsyncIOImpl()
libvirt.registerErrorHandler(_err_handler, '_virt_event')
for id_, h in hypervisors.items():
monitor_tasks.append(
loop.create_task(h['monitor_instance'].watchdog_loop()))
loop.run_until_complete(start_websockets_server)
try:
loop.run_until_complete(asyncio.gather(*monitor_tasks))
except asyncio.CancelledError:
loop.stop()
finally:
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
def virEventLoopAIOStart() -> None:
global eventLoopThread
import libvirtaio
import asyncio
loop = asyncio.new_event_loop()
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
eventLoopThread = threading.Thread(target=virEventLoopAIORun, args=(loop,), name="libvirtEventLoop")
eventLoopThread.setDaemon(True)
eventLoopThread.start()
def virEventLoopAIOStart():
global eventLoopThread
import libvirtaio
import asyncio
loop = asyncio.new_event_loop()
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
eventLoopThread = threading.Thread(target=virEventLoopAIORun, args=(loop,), name="libvirtEventLoop")
eventLoopThread.setDaemon(True)
eventLoopThread.start()
def _register_aio_virt_impl(loop):
# Ensure we may call shell.up() multiple times
# from the same asyncio program.
loop = loop or asyncio.get_event_loop()
if loop not in _register_aio_virt_impl.aio_virt_bindinds:
try:
import libvirtaio
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
except ImportError:
libvirt.virEventRegisterDefaultImpl()
_register_aio_virt_impl.aio_virt_bindinds[loop] = True
def up(virt_lightning_yaml, configuration, context, **kwargs):
def myDomainEventAgentLifecycleCallback(conn, dom, state, reason, opaque):
if state == 1:
logger.info("%s %s QEMU agent found", symbols.CUSTOMS.value,
dom.name())
loop = asyncio.get_event_loop()
try:
import libvirtaio
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
except ImportError:
libvirt.virEventRegisterDefaultImpl()
pass
conn = libvirt.open(configuration.libvirt_uri)
hv = vl.LibvirtHypervisor(conn)
conn.setKeepAlive(5, 3)
conn.domainEventRegisterAny(
None,
libvirt.VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE,
myDomainEventAgentLifecycleCallback,
None,
)
hv.init_network(configuration.network_name, configuration.network_cidr)
hv.init_storage_pool(configuration.storage_pool)
pool = ThreadPoolExecutor(max_workers=10)
async def deploy():
futures = []
for host in virt_lightning_yaml:
futures.append(
loop.run_in_executor(pool, _start_domain, hv, host, context,
configuration))
domain_reachable_futures = []
for f in futures:
await f
domain = f.result()
if domain:
domain_reachable_futures.append(domain.reachable())
logger.info("%s ok Waiting...", symbols.HOURGLASS.value)
await asyncio.gather(*domain_reachable_futures)
loop.run_until_complete(deploy())
logger.info("%s You are all set", symbols.THUMBS_UP.value)
def main(args=None):
loop = asyncio.get_event_loop()
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
try:
args = parser.parse_args(args)
except:
loop.close()
raise
args.app.register_event_handlers()
if args.debug:
qubes.log.enable_debug()
servers = loop.run_until_complete(
qubes.api.create_servers(qubes.api.admin.QubesAdminAPI,
qubes.api.internal.QubesInternalAPI,
qubes.api.misc.QubesMiscAPI,
app=args.app,
debug=args.debug))
socknames = []
for server in servers:
for sock in server.sockets:
socknames.append(sock.getsockname())
for signame in ('SIGINT', 'SIGTERM'):
loop.add_signal_handler(getattr(signal, signame), sighandler, loop,
signame, servers)
qubes.utils.systemd_notify()
# make sure children will not inherit this
os.environ.pop('NOTIFY_SOCKET', None)
try:
loop.run_forever()
loop.run_until_complete(
asyncio.wait([server.wait_closed() for server in servers]))
for sockname in socknames:
try:
os.unlink(sockname)
except FileNotFoundError:
args.app.log.warning(
'socket {} got unlinked sometime before shutdown'.format(
sockname))
finally:
loop.close()
def main(args=None):
loop = asyncio.get_event_loop()
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
try:
args = parser.parse_args(args)
except:
loop.close()
raise
args.app.register_event_handlers()
if args.debug:
qubes.log.enable_debug()
servers = loop.run_until_complete(qubes.api.create_servers(
qubes.api.admin.QubesAdminAPI,
qubes.api.internal.QubesInternalAPI,
qubes.api.misc.QubesMiscAPI,
app=args.app, debug=args.debug))
socknames = []
for server in servers:
for sock in server.sockets:
socknames.append(sock.getsockname())
for signame in ('SIGINT', 'SIGTERM'):
loop.add_signal_handler(getattr(signal, signame),
sighandler, loop, signame, servers)
qubes.utils.systemd_notify()
# make sure children will not inherit this
os.environ.pop('NOTIFY_SOCKET', None)
try:
loop.run_forever()
loop.run_until_complete(asyncio.wait([
server.wait_closed() for server in servers]))
for sockname in socknames:
try:
os.unlink(sockname)
except FileNotFoundError:
args.app.log.warning(
'socket {} got unlinked sometime before shutdown'.format(
sockname))
finally:
loop.close()
def start(configuration, context, **kwargs):
conn = libvirt.open(configuration.libvirt_uri)
hv = vl.LibvirtHypervisor(conn)
hv.init_network(configuration.network_name, configuration.network_cidr)
hv.init_storage_pool(configuration.storage_pool)
host = {
k: kwargs[k]
for k in ["name", "distro", "memory", "vcpus"] if kwargs.get(k)
}
domain = _start_domain(hv, host, context, configuration)
if not domain:
return
loop = asyncio.get_event_loop()
if not kwargs["noconsole"]:
import time
time.sleep(4)
stream = conn.newStream(libvirt.VIR_STREAM_NONBLOCK)
console = domain.dom.openConsole(None, stream, 0)
import libvirtaio
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
def stream_callback(stream, events, _):
content = stream.recv(1024).decode()
sys.stdout.write(content)
stream.eventAddCallback(libvirt.VIR_STREAM_EVENT_READABLE,
stream_callback, console)
async def deploy():
await domain.reachable()
loop.run_until_complete(deploy())
print( # noqa: T001
("\033[0m\n**** System is online ****\n"
"To connect use:\n"
" vl console {name} (virsh console)"
" vl ssh {name}").format(name=domain.name))
if kwargs["ssh"]:
domain.exec_ssh()
in_dom0 = False
#: :py:obj:`False` if outside of git repo,
#: path to root of the directory otherwise
in_git = False
try:
import libvirt
libvirt.openReadOnly(qubes.config.defaults['libvirt_uri']).close()
in_dom0 = True
except libvirt.libvirtError:
pass
if in_dom0:
import libvirtaio
libvirt_event_impl = libvirtaio.virEventRegisterAsyncIOImpl()
else:
libvirt_event_impl = None
try:
in_git = subprocess.check_output(['git', 'rev-parse',
'--show-toplevel']).decode().strip()
qubes.log.LOGPATH = '/tmp'
qubes.log.LOGFILE = '/tmp/qubes.log'
except subprocess.CalledProcessError:
# git returned nonzero, we are outside git repo
pass
except OSError:
# command not found; let's assume we're outside
pass
in_dom0 = False
#: :py:obj:`False` if outside of git repo,
#: path to root of the directory otherwise
in_git = False
try:
import libvirt
libvirt.openReadOnly(qubes.config.defaults['libvirt_uri']).close()
in_dom0 = True
except libvirt.libvirtError:
pass
if in_dom0:
import libvirtaio
libvirt_event_impl = libvirtaio.virEventRegisterAsyncIOImpl()
else:
libvirt_event_impl = None
try:
in_git = subprocess.check_output(
['git', 'rev-parse', '--show-toplevel']).decode().strip()
qubes.log.LOGPATH = '/tmp'
qubes.log.LOGFILE = '/tmp/qubes.log'
except subprocess.CalledProcessError:
# git returned nonzero, we are outside git repo
pass
except OSError:
# command not found; let's assume we're outside
pass
def up(virt_lightning_yaml, configuration, context, **kwargs):
def myDomainEventAgentLifecycleCallback(conn, dom, state, reason, opaque):
if state == 1:
logger.info("%s %s QEMU agent found", symbols.CUSTOMS.value, dom.name())
async def deploy():
futures = []
for host in virt_lightning_yaml:
futures.append(loop.run_in_executor(pool, start_domain, host))
domain_reachable_futures = []
for f in futures:
await f
domain_reachable_futures.append(f.result().reachable())
logger.info("%s ok Waiting...", symbols.HOURGLASS.value)
await asyncio.gather(*domain_reachable_futures)
loop = asyncio.get_event_loop()
try:
import libvirtaio
libvirtaio.virEventRegisterAsyncIOImpl(loop=loop)
except ImportError:
libvirt.virEventRegisterDefaultImpl()
pass
conn = libvirt.open(configuration.libvirt_uri)
hv = vl.LibvirtHypervisor(conn)
conn.setKeepAlive(5, 3)
conn.domainEventRegisterAny(
None,
libvirt.VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE,
myDomainEventAgentLifecycleCallback,
None,
)
hv.init_network(configuration.network_name, configuration.network_cidr)
hv.init_storage_pool(configuration.storage_pool)
def start_domain(host):
if host["distro"] not in hv.distro_available():
logger.error("distro not available: %s", host["distro"])
logger.info(
"Please select on of the following distro: %s", hv.distro_available()
)
exit()
if "name" not in host:
host["name"] = re.sub(r"\W+", "", host["distro"])
if hv.get_domain_by_name(host["name"]):
logger.error("Domain {name} already exists!".format(**host))
exit(1)
# Unfortunatly, i can't decode that symbol
# that symbol more well add to check encoding block
logger.info(
"{lightning} {name} ".format(lightning=symbols.LIGHTNING.value, **host)
)
domain = hv.create_domain(name=host["name"], distro=host["distro"])
domain.context = context
domain.load_ssh_key_file(configuration.ssh_key_file)
domain.username = configuration.username
domain.root_password = host.get("root_password", configuration.root_password)
domain.vcpus(host.get("vcpus"))
domain.memory(host.get("memory", 768))
root_disk_path = hv.create_disk(name=host["name"], backing_on=host["distro"])
domain.add_root_disk(root_disk_path)
domain.attachNetwork(configuration.network_name)
domain.ipv4 = hv.get_free_ipv4()
domain.add_swap_disk(hv.create_disk(host["name"] + "-swap", size=1))
hv.start(domain)
return domain
pool = ThreadPoolExecutor(max_workers=10)
loop.run_until_complete(deploy())
logger.info("%s You are all set", symbols.THUMBS_UP.value)
