def test_read_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=true
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.fromConfig(self.logger, manager.configs[0])
self.assertEquals(type(virt), FakeVirt)
mapping = virt.getHostGuestMapping()
self.assertTrue("hypervisors" in mapping)
hypervisors = mapping["hypervisors"]
self.assertEquals(len(hypervisors), 1)
hypervisor = hypervisors[0]
self.assertEquals(type(hypervisor), Hypervisor)
self.assertEquals(hypervisor.hypervisorId, "60527517-6284-7593-6AAB-75BF2A6375EF")
self.assertEquals(len(hypervisor.guestIds), 1)
guest = hypervisor.guestIds[0]
self.assertEquals(guest.uuid, "07ED8178-95D5-4244-BC7D-582A54A48FF8")
self.assertEquals(guest.state, 1)
def test_read_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=true
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.fromConfig(self.logger, manager.configs[0])
self.assertEquals(type(virt), FakeVirt)
mapping = virt.getHostGuestMapping()
self.assertTrue("hypervisors" in mapping)
hypervisors = mapping["hypervisors"]
self.assertEquals(len(hypervisors), 1)
hypervisor = hypervisors[0]
self.assertEquals(type(hypervisor), Hypervisor)
self.assertEquals(hypervisor.hypervisorId,
"60527517-6284-7593-6AAB-75BF2A6375EF")
self.assertEquals(len(hypervisor.guestIds), 1)
guest = hypervisor.guestIds[0]
self.assertEquals(guest.uuid, "07ED8178-95D5-4244-BC7D-582A54A48FF8")
self.assertEquals(guest.state, 1)
def check_virt_connection(self, config):
queue = Queue()
event = Event()
errors = []
virt = Virt.fromConfig(self.logger, config)
setattr(virt, 'extra_errors',
tempfile.NamedTemporaryFile(prefix='vit-who-error'))
# vdsm subprocess will output to stdout, so redirect it to a tempfile
def _getLocalVdsName(tsPath):
p = subprocess.Popen([
'/usr/bin/openssl', 'x509', '-noout', '-subject', '-in',
'%s/certs/vdsmcert.pem' % tsPath
],
stderr=virt.extra_errors,
stdout=virt.extra_errors,
close_fds=True)
out, err = p.communicate()
if p.returncode != 0:
return '0'
return re.search('/CN=([^/$\n]+)', out).group(1)
if isinstance(virt, Vdsm):
virt._getLocalVdsName = _getLocalVdsName
try:
# Prevent any warning messages to be printed out to the screen. For example:
# certificate warning. Print them to the log instead.
out = StringIO.StringIO()
orig_stdout = sys.stdout
orig_stderr = sys.stderr
sys.stdout = out
sys.stderr = out
# Perform a one shot report request to test the connection
virt.start_sync(queue, event, None, True)
except (VirtError, socket.error) as e:
errors.append(repr(e))
virt.extra_errors.seek(0)
more_errors = virt.extra_errors.read()
if more_errors:
errors.append(more_errors)
for error in errors:
if re.search(r'Connection refused', error, re.I):
errors = ["Please make sure the server port is open."
] + errors
break
finally:
self.logger.info(out.getvalue())
sys.stdout = orig_stdout
sys.stderr = orig_stderr
virt.extra_errors.close()
virt.extra_errors = None
return errors
def test_read_non_hypervisor_from_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.fromConfig(self.logger, manager.configs[0])
self.assertEquals(type(virt), FakeVirt)
self.assertRaises(VirtError, virt.listDomains)
def test_read_non_hypervisor_from_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.fromConfig(self.logger, manager.configs[0])
self.assertEquals(type(virt), FakeVirt)
self.assertRaises(VirtError, virt.listDomains)
def test_read_non_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(NON_HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.fromConfig(self.logger, manager.configs[0])
self.assertEquals(type(virt), FakeVirt)
guests = virt.listDomains()
self.assertEquals(len(guests), 1)
guest = guests[0]
self.assertEquals(guest.uuid, "9f06a84d-5f56-4e7e-be0c-937b3c1924d7")
self.assertEquals(guest.state, 1)
def test_read_non_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(NON_HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.fromConfig(self.logger, manager.configs[0])
self.assertEquals(type(virt), FakeVirt)
guests = virt.listDomains()
self.assertEquals(len(guests), 1)
guest = guests[0]
self.assertEquals(guest.uuid, "9f06a84d-5f56-4e7e-be0c-937b3c1924d7")
self.assertEquals(guest.state, 1)
def run(self):
self.reloading = False
if not self.options.oneshot:
self.logger.debug(
"Starting infinite loop with %d seconds interval",
self.options.interval)
# Queue for getting events from virt backends
if self.queue is None:
self.queue = Queue()
# Run the virtualization backends
self.virts = []
for config in self.configManager.configs:
try:
logger = log.getLogger(config=config)
virt = Virt.fromConfig(logger, config)
except Exception as e:
self.logger.error('Unable to use configuration "%s": %s',
config.name, str(e))
continue
# Run the process
virt.start(self.queue, self.terminate_event, self.options.interval,
self.options.oneshot)
self.virts.append(virt)
# This set is used both for oneshot mode and to bypass rate-limit
# when virt-who is starting
self.oneshot_remaining = set(virt.config.name for virt in self.virts)
if len(self.virts) == 0:
err = "virt-who can't be started: no suitable virt backend found"
self.logger.error(err)
exit(1, err)
# queued reports depend on OrderedDict feature that if key exists
# when setting an item, it will remain in the same order
self.queued_reports.clear()
# Clear last reports, we need to resend them when reloaded
self.last_reports_hash.clear()
# List of reports that are being processed by server
self.reports_in_progress = []
# Send the first report immediately
self.send_after = time.time()
while not self.terminate_event.is_set():
if self.reports_in_progress:
# Check sent report status regularly
timeout = 1
elif time.time() > self.send_after:
if self.queued_reports:
# Reports are queued and we can send them right now,
# don't wait in queue
timeout = 0
else:
# No reports in progress or queued and we can send report
# immediately, we can wait for report as long as we want
timeout = 3600
else:
# We can't send report right now, wait till we can
timeout = max(1, self.send_after - time.time())
# Wait for incoming report from virt backend or for timeout
try:
report = self.queue.get(block=True, timeout=timeout)
except Empty:
report = None
except IOError:
continue
# Read rest of the reports from the queue in order to remove
# obsoleted reports from same virt
while True:
if isinstance(report, ErrorReport):
if self.options.oneshot:
# Don't hang on the failed backend
try:
self.oneshot_remaining.remove(report.config.name)
except KeyError:
pass
self.logger.warn(
'Unable to collect report for config "%s"',
report.config.name)
elif isinstance(report, AbstractVirtReport):
if self.last_reports_hash.get(report.config.name,
None) == report.hash:
self.logger.info(
'Report for config "%s" hasn\'t changed, not sending',
report.config.name)
else:
if report.config.name in self.oneshot_remaining:
# Send the report immediately
self.oneshot_remaining.remove(report.config.name)
if not self.options.print_:
self.send_report(report.config.name, report)
else:
self.queued_reports[
report.config.name] = report
else:
self.queued_reports[report.config.name] = report
elif report in ['exit', 'reload']:
# Reload and exit reports takes priority, do not process
# any other reports
break
# Get next report from queue
try:
report = self.queue.get(block=False)
except Empty:
break
if report == 'exit':
break
elif report == 'reload':
self.stop_virts()
raise ReloadRequest()
self.check_reports_state()
if not self.reports_in_progress and self.queued_reports and time.time(
) > self.send_after:
# No report is processed, send next one
if not self.options.print_:
self.send_current_report()
if self.options.oneshot and not self.oneshot_remaining and not self.reports_in_progress:
break
self.queue = None
self.stop_virts()
self.virt = []
if self.options.print_:
return self.queued_reports
def run(self):
self.reloading = False
if not self.options.oneshot:
self.logger.debug("Starting infinite loop with %d seconds interval", self.options.interval)
# Queue for getting events from virt backends
if self.queue is None:
self.queue = Queue()
# Run the virtualization backends
self.virts = []
for config in self.configManager.configs:
try:
logger = log.getLogger(config=config)
virt = Virt.fromConfig(logger, config)
except Exception as e:
self.logger.error('Unable to use configuration "%s": %s', config.name, str(e))
continue
# Run the process
virt.start(self.queue, self.terminate_event, self.options.interval, self.options.oneshot)
self.virts.append(virt)
# This set is used both for oneshot mode and to bypass rate-limit
# when virt-who is starting
self.oneshot_remaining = set(virt.config.name for virt in self.virts)
if len(self.virts) == 0:
err = "virt-who can't be started: no suitable virt backend found"
self.logger.error(err)
exit(1, err)
# queued reports depend on OrderedDict feature that if key exists
# when setting an item, it will remain in the same order
self.queued_reports.clear()
# Clear last reports, we need to resend them when reloaded
self.last_reports_hash.clear()
# List of reports that are being processed by server
self.reports_in_progress = []
# Send the first report immediately
self.send_after = time.time()
while not self.terminate_event.is_set():
if self.reports_in_progress:
# Check sent report status regularly
timeout = 1
elif time.time() > self.send_after:
if self.queued_reports:
# Reports are queued and we can send them right now,
# don't wait in queue
timeout = 0
else:
# No reports in progress or queued and we can send report
# immediately, we can wait for report as long as we want
timeout = 3600
else:
# We can't send report right now, wait till we can
timeout = max(1, self.send_after - time.time())
# Wait for incoming report from virt backend or for timeout
try:
report = self.queue.get(block=True, timeout=timeout)
except Empty:
report = None
except IOError:
continue
# Read rest of the reports from the queue in order to remove
# obsoleted reports from same virt
while True:
if isinstance(report, ErrorReport):
if self.options.oneshot:
# Don't hang on the failed backend
try:
self.oneshot_remaining.remove(report.config.name)
except KeyError:
pass
self.logger.warn('Unable to collect report for config "%s"', report.config.name)
elif isinstance(report, AbstractVirtReport):
if self.last_reports_hash.get(report.config.name, None) == report.hash:
self.logger.info('Report for config "%s" hasn\'t changed, not sending', report.config.name)
else:
if report.config.name in self.oneshot_remaining:
# Send the report immediately
self.oneshot_remaining.remove(report.config.name)
if not self.options.print_:
self.send_report(report.config.name, report)
else:
self.queued_reports[report.config.name] = report
else:
self.queued_reports[report.config.name] = report
elif report in ['exit', 'reload']:
# Reload and exit reports takes priority, do not process
# any other reports
break
# Get next report from queue
try:
report = self.queue.get(block=False)
except Empty:
break
if report == 'exit':
break
elif report == 'reload':
self.stop_virts()
raise ReloadRequest()
self.check_reports_state()
if not self.reports_in_progress and self.queued_reports and time.time() > self.send_after:
# No report is processed, send next one
if not self.options.print_:
self.send_current_report()
if self.options.oneshot and not self.oneshot_remaining and not self.reports_in_progress:
break
self.queue = None
self.stop_virts()
self.virt = []
if self.options.print_:
return self.queued_reports
