mirror of https://git.48k.eu/ogclient
626 lines
23 KiB
Python
626 lines
23 KiB
Python
#
|
|
# Copyright (C) 2020-2021 Soleta Networks <info@soleta.eu>
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify it under
|
|
# the terms of the GNU Affero General Public License as published by the
|
|
# Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
from src.ogRest import ThreadState
|
|
from src.virtual import poweroffd
|
|
import socket
|
|
import errno
|
|
import select
|
|
import json
|
|
import subprocess
|
|
import shutil
|
|
import os
|
|
import guestfs
|
|
import hivex
|
|
import pathlib
|
|
import re
|
|
import math
|
|
import sys
|
|
import enum
|
|
import time
|
|
from src.log import OgError
|
|
|
|
class OgVM:
|
|
DEFAULT_CPU = 'host'
|
|
DEFAULT_VGA = 'virtio-vga'
|
|
DEFAULT_QMP_IP = 'localhost'
|
|
DEFAULT_QMP_PORT = 4444
|
|
|
|
class State(enum.Enum):
|
|
STOPPED = 0
|
|
RUNNING = 1
|
|
|
|
def __init__(self,
|
|
partition_path,
|
|
memory=None,
|
|
cpu=DEFAULT_CPU,
|
|
vga=DEFAULT_VGA,
|
|
qmp_ip=DEFAULT_QMP_IP,
|
|
qmp_port=DEFAULT_QMP_PORT,
|
|
vnc_params=None):
|
|
self.partition_path = partition_path
|
|
self.cpu = cpu
|
|
self.vga = vga
|
|
self.qmp_ip = qmp_ip
|
|
self.qmp_port = qmp_port
|
|
self.proc = None
|
|
self.vnc_params = vnc_params
|
|
|
|
if memory:
|
|
self.mem = memory
|
|
else:
|
|
available_ram = os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES')
|
|
available_ram = available_ram / 2 ** 20
|
|
# Calculate the lower power of 2 amout of RAM memory for the VM.
|
|
self.mem = 2 ** math.floor(math.log(available_ram) / math.log(2))
|
|
|
|
|
|
def run_vm(self):
|
|
if self.vnc_params:
|
|
vnc_str = f'-vnc 0.0.0.0:0,password'
|
|
else:
|
|
vnc_str = ''
|
|
|
|
cmd = (f'qemu-system-x86_64 -accel kvm -cpu {self.cpu} -smp 4 '
|
|
f'-drive file={self.partition_path},if=virtio '
|
|
f'-qmp tcp:localhost:4444,server,nowait '
|
|
f'-device {self.vga} -display gtk '
|
|
f'-m {self.mem}M -boot c -full-screen {vnc_str}')
|
|
self.proc = subprocess.Popen([cmd], shell=True)
|
|
|
|
if self.vnc_params:
|
|
# Wait for QMP to be available.
|
|
time.sleep(20)
|
|
cmd = { "execute": "change",
|
|
"arguments": { "device": "vnc",
|
|
"target": "password",
|
|
"arg": str(self.vnc_params['pass']) } }
|
|
with OgQMP(self.qmp_ip, self.qmp_port) as qmp:
|
|
qmp.talk(str(cmd))
|
|
|
|
class OgQMP:
|
|
QMP_TIMEOUT = 5
|
|
QMP_POWEROFF_TIMEOUT = 300
|
|
|
|
def __init__(self, ip, port):
|
|
self.ip = ip
|
|
self.port = port
|
|
|
|
def connect(self):
|
|
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
self.sock.setblocking(0)
|
|
try:
|
|
self.sock.connect((self.ip, self.port))
|
|
except socket.error as err:
|
|
if err.errno == errno.ECONNREFUSED:
|
|
raise OgError('Cannot connect to QEMU')
|
|
elif err.errno == errno.EINPROGRESS:
|
|
pass
|
|
|
|
readset = [ self.sock ]
|
|
readable, writable, exception = select.select(readset,
|
|
[],
|
|
[],
|
|
OgQMP.QMP_TIMEOUT)
|
|
|
|
if self.sock in readable:
|
|
try:
|
|
out = self.recv()
|
|
except:
|
|
pass
|
|
|
|
if 'QMP' not in out:
|
|
raise OgError('Cannot handshake QEMU')
|
|
|
|
out = self.talk(str({"execute": "qmp_capabilities"}))
|
|
if 'return' not in out:
|
|
raise OgError('Cannot handshake QEMU')
|
|
|
|
def disconnect(self):
|
|
try:
|
|
self.sock.close()
|
|
except:
|
|
pass
|
|
|
|
def __enter__(self):
|
|
self.connect()
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc_val, exc_tb):
|
|
self.disconnect()
|
|
|
|
def talk(self, data, timeout=QMP_TIMEOUT):
|
|
writeset = [ self.sock ]
|
|
readable, writable, exception = select.select([],
|
|
writeset,
|
|
[],
|
|
timeout)
|
|
if self.sock in writable:
|
|
try:
|
|
self.sock.send(bytes(data, 'utf-8'))
|
|
except Exception as e:
|
|
raise OgError('Cannot talk to QEMU') from e
|
|
else:
|
|
raise OgError('Timeout when talking to QEMU')
|
|
|
|
return self.recv(timeout=timeout)
|
|
|
|
def recv(self, timeout=QMP_TIMEOUT):
|
|
readset = [self.sock]
|
|
readable, _, _ = select.select(readset, [], [], timeout)
|
|
|
|
if self.sock in readable:
|
|
try:
|
|
out = self.sock.recv(4096).decode('utf-8')
|
|
out = json.loads(out)
|
|
except socket.error as err:
|
|
raise OgError('Cannot talk to QEMU') from err
|
|
else:
|
|
raise OgError('Timeout when talking to QEMU')
|
|
return out
|
|
|
|
class OgVirtualOperations:
|
|
def __init__(self):
|
|
self.IP = '127.0.0.1'
|
|
self.VIRTUAL_PORT = 4444
|
|
self.USABLE_DISK = 0.75
|
|
self.OG_PATH = os.path.dirname(os.path.realpath(sys.argv[0]))
|
|
self.OG_IMAGES_PATH = f'{self.OG_PATH}/images'
|
|
self.OG_PARTITIONS_PATH = f'{self.OG_PATH}/partitions'
|
|
self.OG_PARTITIONS_CFG_PATH = f'{self.OG_PATH}/partitions.json'
|
|
|
|
if not os.path.exists(self.OG_IMAGES_PATH):
|
|
os.mkdir(self.OG_IMAGES_PATH, mode=0o755)
|
|
if not os.path.exists(self.OG_PARTITIONS_PATH):
|
|
os.mkdir(self.OG_PARTITIONS_PATH, mode=0o755)
|
|
|
|
def poweroff_guest(self):
|
|
try:
|
|
with OgQMP(self.IP, self.VIRTUAL_PORT) as qmp:
|
|
qmp.talk(str({"execute": "system_powerdown"}))
|
|
out = qmp.recv()
|
|
assert(out['event'] == 'POWERDOWN')
|
|
out = qmp.recv(timeout=OgQMP.QMP_POWEROFF_TIMEOUT)
|
|
assert(out['event'] == 'SHUTDOWN')
|
|
except:
|
|
return
|
|
|
|
def poweroff_host(self):
|
|
subprocess.run(['/sbin/poweroff'])
|
|
|
|
def poweroff(self):
|
|
self.poweroff_guest()
|
|
self.poweroff_host()
|
|
|
|
def reboot(self):
|
|
try:
|
|
with OgQMP(self.IP, self.VIRTUAL_PORT) as qmp:
|
|
qmp.talk(str({"execute": "system_reset"}))
|
|
except:
|
|
pass
|
|
|
|
def check_vm_state(self):
|
|
try:
|
|
with OgQMP(self.IP, self.VIRTUAL_PORT) as qmp:
|
|
pass
|
|
return OgVM.State.RUNNING
|
|
except:
|
|
return OgVM.State.STOPPED
|
|
|
|
def get_installed_os(self):
|
|
installed_os = {}
|
|
try:
|
|
with open(self.OG_PARTITIONS_CFG_PATH, 'r') as f:
|
|
cfg = json.loads(f.read())
|
|
for part in cfg['partition_setup']:
|
|
if len(part['os']) > 0:
|
|
installed_os[part['os']] = (part['disk'], part['partition'])
|
|
except:
|
|
pass
|
|
return installed_os
|
|
|
|
def check_vm_state_loop(self, ogRest):
|
|
# If we can't connect, wait until it's possible.
|
|
while True:
|
|
try:
|
|
with socket.create_connection((poweroffd.QMP_DEFAULT_HOST,
|
|
poweroffd.QMP_DEFAULT_PORT)):
|
|
break
|
|
except ConnectionRefusedError:
|
|
time.sleep(1)
|
|
|
|
qmpconn = poweroffd.init()
|
|
if poweroffd.run(qmpconn) < 0:
|
|
return
|
|
self.poweroff_host()
|
|
|
|
def shellrun(self, request, ogRest):
|
|
return (0, "", "")
|
|
|
|
def session(self, request, ogRest):
|
|
disk = request.getDisk()
|
|
partition = request.getPartition()
|
|
|
|
part_path = f'{self.OG_PARTITIONS_PATH}/disk{disk}_part{partition}.qcow2'
|
|
if ogRest.CONFIG['vnc']['activate']:
|
|
qemu = OgVM(part_path, vnc_params=ogRest.CONFIG['vnc'])
|
|
else:
|
|
qemu = OgVM(part_path)
|
|
qemu.run_vm()
|
|
|
|
def partitions_cfg_to_json(self, data):
|
|
for part in data['partition_setup']:
|
|
part.pop('virt-drive')
|
|
for k, v in part.items():
|
|
part[k] = str(v)
|
|
for disk in data['disk_setup']:
|
|
for k, v in disk.items():
|
|
disk[k] = str(v)
|
|
return data
|
|
|
|
def refresh(self, ogRest):
|
|
try:
|
|
# Return last partitions setup in case VM is running.
|
|
with OgQMP(self.IP, self.VIRTUAL_PORT) as qmp:
|
|
pass
|
|
with open(self.OG_PARTITIONS_CFG_PATH, 'r') as f:
|
|
data = json.loads(f.read())
|
|
data = self.partitions_cfg_to_json(data)
|
|
return data
|
|
except:
|
|
pass
|
|
|
|
try:
|
|
with open(self.OG_PARTITIONS_CFG_PATH, 'r+') as f:
|
|
data = json.loads(f.read())
|
|
for part in data['partition_setup']:
|
|
if len(part['virt-drive']) > 0:
|
|
if not os.path.exists(part['virt-drive']):
|
|
part['code'] = '',
|
|
part['filesystem'] = 'EMPTY'
|
|
part['os'] = ''
|
|
part['size'] = 0
|
|
part['used_size'] = 0
|
|
part['virt-drive'] = ''
|
|
continue
|
|
g = guestfs.GuestFS(python_return_dict=True)
|
|
g.add_drive_opts(part['virt-drive'],
|
|
format="qcow2",
|
|
readonly=1)
|
|
g.launch()
|
|
devices = g.list_devices()
|
|
assert(len(devices) == 1)
|
|
partitions = g.list_partitions()
|
|
assert(len(partitions) == 1)
|
|
filesystems_dict = g.list_filesystems()
|
|
assert(len(filesystems_dict) == 1)
|
|
g.mount(partitions[0], '/')
|
|
used_disk = g.du('/')
|
|
g.umount_all()
|
|
total_size = g.disk_virtual_size(part['virt-drive']) / 1024
|
|
|
|
part['used_size'] = int(100 * used_disk / total_size)
|
|
part['size'] = total_size
|
|
root = g.inspect_os()
|
|
if len(root) == 1:
|
|
part['os'] = f'{g.inspect_get_distro(root[0])} ' \
|
|
f'{g.inspect_get_product_name(root[0])}'
|
|
else:
|
|
part['os'] = ''
|
|
filesystem = [fs for fs in filesystems_dict.values()][0]
|
|
part['filesystem'] = filesystem.upper()
|
|
if filesystem == 'ext4':
|
|
part['code'] = '0083'
|
|
elif filesystem == 'ntfs':
|
|
part['code'] = '0007'
|
|
g.close()
|
|
f.seek(0)
|
|
f.write(json.dumps(data, indent=4))
|
|
f.truncate()
|
|
except FileNotFoundError:
|
|
total_disk, used_disk, free_disk = shutil.disk_usage("/")
|
|
free_disk = int(free_disk * self.USABLE_DISK)
|
|
data = {'serial_number': '',
|
|
'disk_setup': [{'disk': 1,
|
|
'partition': 0,
|
|
'code': '0',
|
|
'filesystem': '',
|
|
'os': '',
|
|
'size': int(free_disk / 1024),
|
|
'used_size': int(100 * used_disk / total_disk)}],
|
|
'partition_setup': []}
|
|
for i in range(4):
|
|
part_json = {'disk': 1,
|
|
'partition': i + 1,
|
|
'code': '',
|
|
'filesystem': 'EMPTY',
|
|
'os': '',
|
|
'size': 0,
|
|
'used_size': 0,
|
|
'virt-drive': ''}
|
|
data['partition_setup'].append(part_json)
|
|
with open(self.OG_PARTITIONS_CFG_PATH, 'w+') as f:
|
|
f.write(json.dumps(data, indent=4))
|
|
except:
|
|
with open(self.OG_PARTITIONS_CFG_PATH, 'r') as f:
|
|
data = json.load(f)
|
|
|
|
data = self.partitions_cfg_to_json(data)
|
|
|
|
return data
|
|
|
|
def setup(self, request, ogRest):
|
|
self.poweroff_guest()
|
|
self.refresh(ogRest)
|
|
|
|
part_setup = request.getPartitionSetup()
|
|
disk = request.getDisk()
|
|
|
|
for i, part in enumerate(part_setup):
|
|
if int(part['format']) == 0:
|
|
continue
|
|
|
|
drive_path = f'{self.OG_PARTITIONS_PATH}/disk{disk}_part{part["partition"]}.qcow2'
|
|
g = guestfs.GuestFS(python_return_dict=True)
|
|
g.disk_create(drive_path, "qcow2", int(part['size']) * 1024)
|
|
g.add_drive_opts(drive_path, format="qcow2", readonly=0)
|
|
g.launch()
|
|
devices = g.list_devices()
|
|
assert(len(devices) == 1)
|
|
g.part_disk(devices[0], "gpt")
|
|
partitions = g.list_partitions()
|
|
assert(len(partitions) == 1)
|
|
g.mkfs(part["filesystem"].lower(), partitions[0])
|
|
g.close()
|
|
|
|
with open(self.OG_PARTITIONS_CFG_PATH, 'r+') as f:
|
|
data = json.loads(f.read())
|
|
if part['code'] == 'LINUX':
|
|
data['partition_setup'][i]['code'] = '0083'
|
|
elif part['code'] == 'NTFS':
|
|
data['partition_setup'][i]['code'] = '0007'
|
|
elif part['code'] == 'DATA':
|
|
data['partition_setup'][i]['code'] = '00da'
|
|
data['partition_setup'][i]['filesystem'] = part['filesystem']
|
|
data['partition_setup'][i]['size'] = int(part['size'])
|
|
data['partition_setup'][i]['virt-drive'] = drive_path
|
|
f.seek(0)
|
|
f.write(json.dumps(data, indent=4))
|
|
f.truncate()
|
|
|
|
return self.refresh(ogRest)
|
|
|
|
def image_create(self, path, request, ogRest):
|
|
disk = request.getDisk()
|
|
partition = request.getPartition()
|
|
name = request.getName()
|
|
repo = request.getRepo()
|
|
samba_config = ogRest.samba_config
|
|
|
|
self.poweroff_guest()
|
|
|
|
self.refresh(ogRest)
|
|
|
|
drive_path = f'{self.OG_PARTITIONS_PATH}/disk{disk}_part{partition}.qcow2'
|
|
|
|
cmd = f'mount -t cifs //{repo}/ogimages {self.OG_IMAGES_PATH} -o ' \
|
|
f'rw,nolock,serverino,acl,' \
|
|
f'username={samba_config["user"]},' \
|
|
f'password={samba_config["pass"]}'
|
|
subprocess.run([cmd], shell=True)
|
|
|
|
try:
|
|
shutil.copy(drive_path, f'{self.OG_IMAGES_PATH}/{name}')
|
|
except:
|
|
return None
|
|
|
|
subprocess.run([f'umount {self.OG_IMAGES_PATH}'], shell=True, check=True)
|
|
|
|
return True
|
|
|
|
def image_restore(self, request, ogRest):
|
|
disk = request.getDisk()
|
|
partition = request.getPartition()
|
|
name = request.getName()
|
|
repo = request.getRepo()
|
|
# TODO Multicast? Unicast? Solo copia con samba.
|
|
ctype = request.getType()
|
|
profile = request.getProfile()
|
|
cid = request.getId()
|
|
samba_config = ogRest.samba_config
|
|
|
|
self.poweroff_guest()
|
|
self.refresh(ogRest)
|
|
|
|
drive_path = f'{self.OG_PARTITIONS_PATH}/disk{disk}_part{partition}.qcow2'
|
|
|
|
if os.path.exists(drive_path):
|
|
os.remove(drive_path)
|
|
|
|
cmd = f'mount -t cifs //{repo}/ogimages {self.OG_IMAGES_PATH} -o ' \
|
|
f'ro,nolock,serverino,acl,' \
|
|
f'username={samba_config["user"]},' \
|
|
f'password={samba_config["pass"]}'
|
|
subprocess.run([cmd], shell=True, check=True)
|
|
|
|
try:
|
|
copy_src = f'{self.OG_IMAGES_PATH}/{name}'
|
|
shutil.copy(copy_src, drive_path)
|
|
except Exception as e:
|
|
raise OgError(f'Error trying to copy {copy_src} into {drive_path}: {e}') from e
|
|
|
|
subprocess.run([f'umount {self.OG_IMAGES_PATH}'], shell=True)
|
|
self.refresh(ogRest)
|
|
|
|
json_dict = {
|
|
'disk': request.getDisk(),
|
|
'partition': request.getPartition(),
|
|
'image_id': request.getId(),
|
|
'cache': [],
|
|
}
|
|
|
|
return json_dict
|
|
|
|
def cache_delete(self, request, ogRest):
|
|
raise NotImplementedError
|
|
|
|
def cache_fetch(self, request, ogRest):
|
|
raise NotImplementedError
|
|
|
|
def software(self, request, path, ogRest):
|
|
DPKG_PATH = '/var/lib/dpkg/status'
|
|
|
|
disk = request.getDisk()
|
|
partition = request.getPartition()
|
|
drive_path = f'{self.OG_PARTITIONS_PATH}/disk{disk}_part{partition}.qcow2'
|
|
g = guestfs.GuestFS(python_return_dict=True)
|
|
g.add_drive_opts(drive_path, readonly=1)
|
|
g.launch()
|
|
root = g.inspect_os()[0]
|
|
|
|
os_type = g.inspect_get_type(root)
|
|
os_major_version = g.inspect_get_major_version(root)
|
|
os_minor_version = g.inspect_get_minor_version(root)
|
|
os_distro = g.inspect_get_distro(root)
|
|
|
|
software = []
|
|
|
|
if 'linux' in os_type:
|
|
g.mount_ro(g.list_partitions()[0], '/')
|
|
try:
|
|
g.download('/' + DPKG_PATH, 'dpkg_list')
|
|
except:
|
|
pass
|
|
g.umount_all()
|
|
if os.path.isfile('dpkg_list'):
|
|
pkg_pattern = re.compile('Package: (.+)')
|
|
version_pattern = re.compile('Version: (.+)')
|
|
with open('dpkg_list', 'r') as f:
|
|
for line in f:
|
|
pkg_match = pkg_pattern.match(line)
|
|
version_match = version_pattern.match(line)
|
|
if pkg_match:
|
|
pkg = pkg_match.group(1)
|
|
elif version_match:
|
|
version = version_match.group(1)
|
|
elif line == '\n':
|
|
software.append(pkg + ' ' + version)
|
|
else:
|
|
continue
|
|
os.remove('dpkg_list')
|
|
elif 'windows' in os_type:
|
|
g.mount_ro(g.list_partitions()[0], '/')
|
|
hive_file_path = g.inspect_get_windows_software_hive(root)
|
|
g.download('/' + hive_file_path, 'win_reg')
|
|
g.umount_all()
|
|
h = hivex.Hivex('win_reg')
|
|
key = h.root()
|
|
key = h.node_get_child (key, 'Microsoft')
|
|
key = h.node_get_child (key, 'Windows')
|
|
key = h.node_get_child (key, 'CurrentVersion')
|
|
key = h.node_get_child (key, 'Uninstall')
|
|
software += [h.node_name(x) for x in h.node_children(key)]
|
|
# Just for 64 bit Windows versions, check for 32 bit software.
|
|
if (os_major_version == 5 and os_minor_version >= 2) or \
|
|
(os_major_version >= 6):
|
|
key = h.root()
|
|
key = h.node_get_child (key, 'Wow6432Node')
|
|
key = h.node_get_child (key, 'Microsoft')
|
|
key = h.node_get_child (key, 'Windows')
|
|
key = h.node_get_child (key, 'CurrentVersion')
|
|
key = h.node_get_child (key, 'Uninstall')
|
|
software += [h.node_name(x) for x in h.node_children(key)]
|
|
os.remove('win_reg')
|
|
|
|
return '\n'.join(software)
|
|
|
|
def parse_pci(self, path='/usr/share/misc/pci.ids'):
|
|
data = {}
|
|
with open(path, 'r') as f:
|
|
for line in f:
|
|
if line[0] == '#':
|
|
continue
|
|
elif len(line.strip()) == 0:
|
|
continue
|
|
else:
|
|
if line[:2] == '\t\t':
|
|
fields = line.strip().split(maxsplit=2)
|
|
data[last_vendor][last_device][(fields[0], fields[1])] = fields[2]
|
|
elif line[:1] == '\t':
|
|
fields = line.strip().split(maxsplit=1)
|
|
last_device = fields[0]
|
|
data[last_vendor][fields[0]] = {'name': fields[1]}
|
|
else:
|
|
fields = line.strip().split(maxsplit=1)
|
|
if fields[0] == 'ffff':
|
|
break
|
|
last_vendor = fields[0]
|
|
data[fields[0]] = {'name': fields[1]}
|
|
return data
|
|
|
|
def hardware(self, path, ogRest):
|
|
try:
|
|
with OgQMP(self.IP, self.VIRTUAL_PORT) as qmp:
|
|
pci_data = qmp.talk(str({"execute": "query-pci"}))
|
|
mem_data = qmp.talk(str({"execute": "query-memory-size-summary"}))
|
|
cpu_data = qmp.talk(str({"execute": "query-cpus-fast"}))
|
|
except:
|
|
return
|
|
|
|
pci_data = pci_data['return'][0]['devices']
|
|
pci_list = self.parse_pci()
|
|
device_names = {}
|
|
for device in pci_data:
|
|
vendor_id = hex(device['id']['vendor'])[2:]
|
|
device_id = hex(device['id']['device'])[2:]
|
|
subvendor_id = hex(device['id']['subsystem-vendor'])[2:]
|
|
subdevice_id = hex(device['id']['subsystem'])[2:]
|
|
description = device['class_info']['desc'].lower()
|
|
name = ''
|
|
try:
|
|
name = pci_list[vendor_id]['name']
|
|
name += ' ' + pci_list[vendor_id][device_id]['name']
|
|
name += ' ' + pci_list[vendor_id][device_id][(subvendor_id, subdevice_id)]
|
|
except KeyError:
|
|
if vendor_id == '1234':
|
|
name = 'VGA Cirrus Logic GD 5446'
|
|
else:
|
|
pass
|
|
|
|
if 'usb' in description:
|
|
device_names['usb'] = name
|
|
elif 'ide' in description:
|
|
device_names['ide'] = name
|
|
elif 'ethernet' in description:
|
|
device_names['net'] = name
|
|
elif 'vga' in description:
|
|
device_names['vga'] = name
|
|
|
|
elif 'audio' in description or 'sound' in description:
|
|
device_names['aud'] = name
|
|
elif 'dvd' in description:
|
|
device_names['cdr'] = name
|
|
|
|
ram_size = int(mem_data['return']['base-memory']) * 2 ** -20
|
|
device_names['mem'] = f'QEMU {int(ram_size)}MiB'
|
|
|
|
cpu_arch = cpu_data['return'][0]['arch']
|
|
cpu_target = cpu_data['return'][0]['target']
|
|
cpu_cores = len(cpu_data['return'])
|
|
device_names['cpu'] = f'CPU arch:{cpu_arch} target:{cpu_target} ' \
|
|
f'cores:{cpu_cores}'
|
|
|
|
with open(path, 'w+') as f:
|
|
f.seek(0)
|
|
for k, v in device_names.items():
|
|
f.write(f'{k}={v}\n')
|
|
f.truncate()
|
|
|
|
def probe(self, ogRest):
|
|
return {'status': 'VDI' if ogRest.state != ThreadState.BUSY else 'BSY'}
|