def _on_recv(self, handle, addr, flags, data, error):
if error is not None:
logger.warning('error reading from UDP endpoint: {} - {}'.format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
else:
self._protocol.datagram_received(data, addr)
def _on_recv(self, handle, addr, flags, data, error):
if error is not None:
logger.warning("error reading from UDP endpoint: {} - {}".format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
else:
self._protocol.datagram_received(data, addr)
def _do_waitpid(self, loop, expected_pid, callback, args):
assert expected_pid > 0
try:
pid, status = os.waitpid(expected_pid, 0)
except ChildProcessError:
# The child process is already reaped
# (may happen if waitpid() is called elsewhere).
pid = expected_pid
returncode = 255
logger.warning(
"Unknown child process pid %d, will report returncode 255", pid
)
else:
returncode = _compute_returncode(status)
if loop.get_debug():
logger.debug(
"process %s exited with returncode %s", expected_pid, returncode
)
if loop.is_closed():
logger.warning("Loop %r that handles pid %r is closed", loop, pid)
else:
loop.call_soon_threadsafe(callback, pid, returncode, *args)
self._threads.pop(expected_pid)
def data_received(self, data):
"""Called when some SSL data is received.
The argument is a bytes object.
"""
if self._sslpipe is None:
# transport closing, sslpipe is destroyed
return
try:
ssldata, appdata = self._sslpipe.feed_ssldata(data)
except ssl.SSLError as e:
if self._loop.get_debug():
logger.warning("%r: SSL error %s (reason %s)", self, e.errno,
e.reason)
self._abort()
return
for chunk in ssldata:
self._transport.write(chunk)
for chunk in appdata:
if chunk:
self._app_protocol.data_received(chunk)
else:
self._start_shutdown()
break
def write(self, data):
assert isinstance(data, (bytes, bytearray, memoryview)), repr(data)
if isinstance(data, bytearray):
data = memoryview(data)
if not data:
return
if self._conn_lost or self._closing:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('pipe closed by peer or '
'os.write(pipe, data) raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Attempt to send it right away first.
try:
n = os.write(self._fileno, data)
except (BlockingIOError, InterruptedError):
n = 0
except Exception as exc:
self._conn_lost += 1
self._fatal_error(exc)
return
if n == len(data):
return
elif n > 0:
data = data[n:]
self._loop.add_writer(self._fileno, self._write_ready)
self._buffer.append(data)
self._maybe_pause_protocol()
def lom_cdn_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-003
Test Case: To Verify Consistent device naming structure for LOM Ports-RHEL 7.0
Pass/Fail Criteria: Device Naming should appear as specified in the Functional Spec
'''
vic_obj = VicLib(cimc_util_obj, config)
logger.info('Fetch the host managment interface IP')
ntw_list = config.host_info[0].nw_intf_list
logger.info('Management interface is:' + ntw_list[0].is_mgmt_intf)
host_ip = get_host_mgmt_ip(config)
res = cimc_util_obj.verify_host_up(host_ip,
wait_time=400,
wait_for_ping_fail=False)
if res is False:
logger.warning('Failed to ping the host after host reboot')
else:
logger.info("Host name IP pinging successfully")
# connect to host
cimc_util_obj.host_handle.connect()
logger.info('Successfully connected to host')
host_dict = vic_obj.host_cdn_mac_dict(cimc_util_obj.host_handle,
'biosdevname -d')
cdn_name_from_host = []
for cdn_name_from_host1 in host_dict.values():
cdn_name_from_host.append(cdn_name_from_host1)
if "LOMPort1" and "LOMPort2" in cdn_name_from_host:
self.passed(
"LOMPort1 and LOMPort2 available in Host OS, when CDN Enabled")
else:
self.passed(
'LOMPort1 and LOMPort2 are not available in Host OS, when CDN Enabled'
)
def write(self, data):
assert isinstance(data, (bytes, bytearray, memoryview)), repr(data)
if isinstance(data, bytearray):
data = memoryview(data)
if not data:
return
if self._conn_lost or self._closing:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('pipe closed by peer or '
'os.write(pipe, data) raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Attempt to send it right away first.
try:
n = os.write(self._fileno, data)
except (BlockingIOError, InterruptedError):
n = 0
except Exception as exc:
self._conn_lost += 1
self._fatal_error(exc)
return
if n == len(data):
return
elif n > 0:
data = data[n:]
self._loop.add_writer(self._fileno, self._write_ready)
self._buffer.append(data)
self._maybe_pause_protocol()
def write(self, data):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError('data argument must be byte-ish (%r)',
type(data))
if self._eof:
raise RuntimeError('Cannot call write() after write_eof()')
if not data:
return
if self._conn_lost:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Optimization: try to send now.
try:
n = self._sock.send(data)
except (BlockingIOError, InterruptedError):
pass
except Exception as exc:
self._fatal_error(exc)
return
else:
data = data[n:]
if not data:
return
# Not all was written; register write handler.
self._loop.add_writer(self._sock_fd, self._write_ready)
# Add it to the buffer.
self._buffer.extend(data)
self._maybe_pause_protocol()
def _read_ready(self):
if self._write_wants_read:
self._write_wants_read = False
self._write_ready()
if self._buffer:
self._loop.add_writer(self._sock_fd, self._write_ready)
try:
data = self._sock.recv(self.max_size)
except (BlockingIOError, InterruptedError, ssl.SSLWantReadError):
pass
except ssl.SSLWantWriteError:
self._read_wants_write = True
self._loop.remove_reader(self._sock_fd)
self._loop.add_writer(self._sock_fd, self._write_ready)
except Exception as exc:
self._fatal_error(exc)
else:
if data:
self._protocol.data_received(data)
else:
try:
keep_open = self._protocol.eof_received()
if keep_open:
logger.warning('returning true from eof_received() '
'has no effect when using ssl')
finally:
self.close()
def _read_ready(self):
if self._write_wants_read:
self._write_wants_read = False
self._write_ready()
if self._buffer:
self._loop.add_writer(self._sock_fd, self._write_ready)
try:
data = self._sock.recv(self.max_size)
except (BlockingIOError, InterruptedError, ssl.SSLWantReadError):
pass
except ssl.SSLWantWriteError:
self._read_wants_write = True
self._loop.remove_reader(self._sock_fd)
self._loop.add_writer(self._sock_fd, self._write_ready)
except Exception as exc:
self._fatal_error(exc)
else:
if data:
self._protocol.data_received(data)
else:
try:
keep_open = self._protocol.eof_received()
if keep_open:
logger.warning('returning true from eof_received() '
'has no effect when using ssl')
finally:
self.close()
def write(self, data):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError('data argument must be byte-ish (%r)', type(data))
if self._eof:
raise RuntimeError('Cannot call write() after write_eof()')
if not data:
return
if self._conn_lost:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Optimization: try to send now.
try:
n = self._sock.send(data)
except (BlockingIOError, InterruptedError):
pass
except Exception as exc:
self._fatal_error(exc)
return
else:
data = data[n:]
if not data:
return
# Not all was written; register write handler.
self._loop.add_writer(self._sock_fd, self._write_ready)
# Add it to the buffer.
self._buffer.extend(data)
self._maybe_pause_protocol()
def attach(self, loop):
if self._loop:
l = self._loop()
if l and l != loop:
logger.warning(
"Multiple event loops for the GLib default context. "
"SIGINT may not be caught reliably")
self._loop = weakref.ref(loop)
def attach(self, loop):
if self._loop:
l = self._loop()
if l and l != loop:
logger.warning(
"Multiple event loops for the GLib default context. "
"SIGINT may not be caught reliably")
self._loop = weakref.ref(loop)
def _on_handshake_complete(self, handshake_exc):
self._in_handshake = False
sslobj = self._sslpipe.ssl_object
try:
if handshake_exc is not None:
raise handshake_exc
peercert = sslobj.getpeercert()
if not hasattr(self._sslcontext, "check_hostname"):
# Verify hostname if requested, Python 3.4+ uses check_hostname
# and checks the hostname in do_handshake()
if (self._server_hostname
and self._sslcontext.verify_mode != ssl.CERT_NONE):
ssl.match_hostname(peercert, self._server_hostname)
except BaseException as exc:
if self._loop.get_debug():
if isinstance(exc, ssl.CertificateError):
logger.warning(
"%r: SSL handshake failed "
"on verifying the certificate",
self,
exc_info=True,
)
else:
logger.warning("%r: SSL handshake failed",
self,
exc_info=True)
self._transport.close()
if isinstance(exc, Exception):
self._wakeup_waiter(exc)
return
else:
raise
if self._loop.get_debug():
dt = self._loop.time() - self._handshake_start_time
logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
# Add extra info that becomes available after handshake.
self._extra.update(
peercert=peercert,
cipher=sslobj.cipher(),
compression=sslobj.compression(),
ssl_object=sslobj,
)
if self._call_connection_made:
self._app_protocol.connection_made(self._app_transport)
self._wakeup_waiter()
self._session_established = True
# In case transport.write() was already called. Don't call
# immediately _process_write_backlog(), but schedule it:
# _on_handshake_complete() can be called indirectly from
# _process_write_backlog(), and _process_write_backlog() is not
# reentrant.
self._loop.call_soon(self._process_write_backlog)
def _pipe_listen_cb(server, error):
if error is not None:
logger.warning('error processing incoming Pipe connection: {} - {}'.format(error, pyuv.errno.strerror(error)))
return
conn = pyuv.Pipe(server.loop)
try:
server.accept(conn)
except pyuv.error.PipeError as e:
error = e.args[0]
logger.warning('error accepting incoming Pipe connection: {} - {}'.format(error, pyuv.errno.strerror(error)))
return
return PipeTransport(conn.loop._rose_loop, server.protocol_factory(), conn)
def _pipe_listen_cb(server, error):
if error is not None:
logger.warning("error processing incoming Pipe connection: {} - {}".format(error, pyuv.errno.strerror(error)))
return
conn = pyuv.Pipe(server.loop)
try:
server.accept(conn)
except pyuv.error.PipeError as e:
error = e.args[0]
logger.warning("error accepting incoming Pipe connection: {} - {}".format(error, pyuv.errno.strerror(error)))
return
return PipeTransport(conn.loop._rose_loop, server.protocol_factory(), conn)
def _tcp_listen_cb(server, error):
if error is not None:
logger.warning('error processing incoming TCP connection: {} - {}'.format(error, pyuv.errno.strerror(error)))
return
conn = pyuv.TCP(server.loop)
try:
server.accept(conn)
except pyuv.error.TCPError as e:
error = e.args[0]
logger.warning('error accepting incoming TCP connection: {} - {}'.format(error, pyuv.errno.strerror(error)))
return
addr = conn.getpeername()
return TCPTransport(conn.loop._rose_loop, server.protocol_factory(), conn, extra={'addr': addr})
def _tcp_listen_cb(server, error):
if error is not None:
logger.warning("error processing incoming TCP connection: {} - {}".format(error, pyuv.errno.strerror(error)))
return
conn = pyuv.TCP(server.loop)
try:
server.accept(conn)
except pyuv.error.TCPError as e:
error = e.args[0]
logger.warning("error accepting incoming TCP connection: {} - {}".format(error, pyuv.errno.strerror(error)))
return
addr = conn.getpeername()
return TCPTransport(conn.loop._rose_loop, server.protocol_factory(), conn, extra={"peername": addr})
def _on_read(self, handle, data, error):
if error is not None:
if error == pyuv.errno.UV_EOF:
# connection closed by remote
try:
self._protocol.eof_received()
finally:
self.close()
else:
logger.warning("error reading from connection: {} - {}".format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
else:
self._protocol.data_received(data)
def _on_read(self, handle, data, error):
if error is not None:
if error == pyuv.errno.UV_EOF:
# connection closed by remote
try:
self._protocol.eof_received()
finally:
self.close()
else:
logger.warning('error reading from connection: {} - {}'.format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
else:
self._protocol.data_received(data)
def cdn_enable_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-003
Test Case: To Check CDN is Enabled from CIMC
'''
vic_list = config.inventory_detail
logger.info('VIC list are: ' + str(vic_list))
bios_obj = cimc_util_obj.bios_util_obj
host_util = HostUtils()
boot_order_obj = BootOrder(cimc_util_obj)
status = host_util.check_host_up(cimc_util_obj, boot_order_obj, config)
if status is False:
logger.warning(
'Host OS is not pinging after setting the boot order to HDD ')
bios_token = 'cdnEnable'
token_new_value = 'Enabled'
logger.info('Power on the host')
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
host_ip = get_host_mgmt_ip(config)
token_val = bios_obj.get_bios_token_value(bios_token)
if token_val == token_new_value:
logger.info('CDN is already enabled on CIMC')
else:
logger.info('Set the cdnEnable token Enable and Reboot the host')
res = bios_obj.set_bios_token_value(bios_token, token_new_value)
if res is False:
logger.error('Failed to set bios token value')
self.failed('Failed to set bios token value', goto=['cleanup'])
'''Wait for host to reboot'''
res = cimc_util_obj.verify_host_up(host_ip,
wait_for_ping_fail=False,
wait_time=400)
if res is False:
logger.warning('Failed to ping the host after host reboot')
self.failed('Failed to ping host', goto=['cleanup'])
scope = 'advanced'
token_val = bios_obj.get_bios_token_value(bios_token)
if token_val == token_new_value:
self.passed(
'Successfully verified that CDN token can be enabled from CIMC'
)
else:
self.failed('Failed to verify that CDN token,\
Expected is:' + token_new_value + ' But got as: ' +
token_val)
def write(self, data):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError('data argument must be byte-ish (%r)', type(data))
if not data:
return
if self._conn_lost:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
if not self._buffer:
self._loop.add_writer(self._sock_fd, self._write_ready)
# Add it to the buffer.
self._buffer.extend(data)
self._maybe_pause_protocol()
def Verify_Tech_support_report(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-022
Test Case: Check for CDN detail from Tech Support log
Pass/Fail Criteria: CDN names and its details should appear correctly in Techsupport log
Author: lakkris2
'''
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
'''creating 2 vNIC interface'''
dev_list = ['9', '10']
if create_vnic_interface(self, vic_obj, slot_no,
dev_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
cimc_util_obj.power_cycle_host()
host_ip = get_host_mgmt_ip(config)
res = cimc_util_obj.verify_host_up(host_ip,
wait_time=400,
wait_for_ping_fail=False)
if res is False:
logger.warning('Failed to ping the host after host reboot')
else:
logger.info("Host name IP pinging successfully")
out = cimc_util_obj.upload_techsupport_data(protocol='tftp')
if out is False:
self.failed('Failed to upload tech-support data', goto=['cleanup'])
res = cimc_util_obj.validate_cdn_techsupport(config)
if res is False:
self.failed(
'Failed to verify that CDN info consistent across CIMC and VIC exported \
files',
goto=['cleanup'])
else:
self.passed(
'Successfully verified that CDN info consistent across CIMC and VIC config'
)
cimc_util_obj.remove_techsupport_file()
def write(self, data):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError('data argument must be byte-ish (%r)',
type(data))
if not data:
return
if self._conn_lost:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
if not self._buffer:
self._loop.add_writer(self._sock_fd, self._write_ready)
# Add it to the buffer.
self._buffer.extend(data)
self._maybe_pause_protocol()
def eof_received(self):
"""Called when the other end of the low-level stream
is half-closed.
If this returns a false value (including None), the transport
will close itself. If it returns a true value, closing the
transport is up to the protocol.
"""
try:
if self._loop.get_debug():
logger.debug("%r received EOF", self)
self._wakeup_waiter(ConnectionResetError)
if not self._in_handshake:
keep_open = self._app_protocol.eof_received()
if keep_open:
logger.warning("returning true from eof_received() "
"has no effect when using ssl")
finally:
self._transport.close()
def run_frame(self):
event_list = self._selector.select(0)
self._process_events(event_list)
ntodo = len(self._ready)
for i in range(ntodo):
handle = self._ready.popleft()
if handle._cancelled:
continue
if self._debug:
try:
self._current_handle = handle
t0 = self.time()
handle._run()
dt = self.time() - t0
if dt >= self.slow_callback_duration:
logger.warning('Executing %s took %.3f seconds',
_format_handle(handle), dt)
finally:
self._current_handle = None
else:
handle._run()
handle = None # Needed to break cycles when an exception occurs.
def sendto(self, data, addr=None):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError('data argument must be byte-ish (%r)',
type(data))
if not data:
return
if self._address and addr not in (None, self._address):
raise ValueError('Invalid address: must be None or %s' %
(self._address,))
if self._conn_lost and self._address:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Attempt to send it right away first.
try:
if self._address:
self._sock.send(data)
else:
self._sock.sendto(data, addr)
return
except (BlockingIOError, InterruptedError):
self._loop.add_writer(self._sock_fd, self._sendto_ready)
except OSError as exc:
self._protocol.error_received(exc)
return
except Exception as exc:
self._fatal_error(exc)
return
# Ensure that what we buffer is immutable.
self._buffer.append((bytes(data), addr))
self._maybe_pause_protocol()
def sendto(self, data, addr=None):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError('data argument must be byte-ish (%r)', type(data))
if not data:
return
if self._address and addr not in (None, self._address):
raise ValueError('Invalid address: must be None or %s' %
(self._address, ))
if self._conn_lost and self._address:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Attempt to send it right away first.
try:
if self._address:
self._sock.send(data)
else:
self._sock.sendto(data, addr)
return
except (BlockingIOError, InterruptedError):
self._loop.add_writer(self._sock_fd, self._sendto_ready)
except OSError as exc:
self._protocol.error_received(exc)
return
except Exception as exc:
self._fatal_error(exc)
return
# Ensure that what we buffer is immutable.
self._buffer.append((bytes(data), addr))
self._maybe_pause_protocol()
def _on_send(self, handle, error):
if error is not None:
logger.warning('error sending to UDP endpoint: {} - {}'.format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
def _on_write(self, handle, error):
if error is not None:
logger.warning("error writing to connection: {} - {}".format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
return
def _run_once(self):
"""Run one full iteration of the event loop. This calls all
currently ready callbacks, polls for I/O, schedules the
resulting callbacks, and finally schedules 'call_later'
callbacks.
"""
# log.debug("run_once()")
sched_count = len(self._scheduled)
if (sched_count > _MIN_SCHEDULED_TIMER_HANDLES
and self._timer_cancelled_count / sched_count >
_MIN_CANCELLED_TIMER_HANDLES_FRACTION):
# Remove delayed calls that were cancelled if their number
# is too high
new_scheduled = []
for handle in self._scheduled:
if handle._cancelled:
handle._scheduled = False
else:
new_scheduled.append(handle)
heapq.heapify(new_scheduled)
self._scheduled = new_scheduled
self._timer_cancelled_count = 0
else:
# Remove delayed calls that were cancelled from head of queue.
while self._scheduled and self._scheduled[0]._cancelled:
self._timer_cancelled_count -= 1
handle = heapq.heappop(self._scheduled)
handle._scheduled = False
# print("***", self._ready)
# print("***", self._scheduled)
# Handle 'later' callbacks that are ready.
while self._scheduled and not self._ready:
handle = self._scheduled[0]
handle = heapq.heappop(self._scheduled)
handle._scheduled = False
log.debug("Advancing time from %s to %s", self._time, handle._when)
self._time = max(handle._when, self._time)
self._ready.append(handle)
# This is the only place where callbacks are actually *called*.
# All other places just add them to ready. Note: We run all
# currently scheduled callbacks, but not any callbacks scheduled
# by callbacks run this time around -- they will be run the next
# time (after another I/O poll). Use an idiom that is
# thread-safe without using locks.
ntodo = len(self._ready)
for i in range(ntodo):
handle = self._ready.popleft()
if handle._cancelled:
continue
if self._debug:
try:
self._current_handle = handle
t0 = self.time()
handle._run()
dt = self.time() - t0
if dt >= self.slow_callback_duration:
logger.warning("Executing %s took %.3f seconds",
_format_handle(handle), dt)
finally:
self._current_handle = None
else:
handle._run()
handle = None # Needed to break cycles when an exception occurs.
def _run_once(self):
"""Run one full iteration of the event loop.
This calls all currently ready callbacks, polls for I/O,
schedules the resulting callbacks, and finally schedules
'call_later' callbacks.
Basically a copy of the original one, but running ready
callbacks applying a round robin strategy between the differnet
partitions. Once a queue, if it had at least one callback, runs out
of callbacks the IO loop is requested again for its IO and time
handles.
"""
sched_count = sum(
[len(self._partitions[p].scheduled) for p in self._p_to_process])
if (sched_count > _MIN_SCHEDULED_TIMER_HANDLES
and self._timer_cancelled_count / sched_count >
_MIN_CANCELLED_TIMER_HANDLES_FRACTION): # noqa
for partition in self._p_to_process:
# Remove delayed calls that were cancelled if their number
# is too high
new_scheduled = []
for handle in self._partitions[partition].scheduled:
if handle._cancelled:
handle._scheduled = False
else:
new_scheduled.append(handle)
heapq.heapify(new_scheduled)
self._partitions[partition].scheduled = new_scheduled
self._timer_cancelled_count = 0
else:
for partition in self._p_to_process:
# Remove delayed calls that were cancelled from head of queue.
while self._partitions[partition].scheduled and\
self._partitions[partition].scheduled[0]._cancelled:
self._timer_cancelled_count -= 1
handle = heapq.heappop(
self._partitions[partition].scheduled)
handle._scheduled = False
timeout = None
any_handles = any(
[bool(self._partitions[p].handles) for p in self._partitions])
any_scheduled = any(
[bool(self._partitions[p].scheduled) for p in self._p_to_process])
if any_handles or self._stopping:
timeout = 0
elif any_scheduled:
# Compute the desired timeout.
when = min([
self._partitions[p].scheduled[0]._when
for p in self._p_to_process
] # noqa
)
timeout = max(0, when - self.time())
if self._debug and timeout != 0:
t0 = self.time()
event_list = self._selector.select(timeout)
dt = self.time() - t0
if dt >= 1.0:
level = logging.INFO
else:
level = logging.DEBUG
nevent = len(event_list)
if timeout is None:
logger.log(level, 'poll took %.3f ms: %s events', dt * 1e3,
nevent)
elif nevent:
logger.log(level, 'poll %.3f ms took %.3f ms: %s events',
timeout * 1e3, dt * 1e3, nevent)
elif dt >= 1.0:
logger.log(level, 'poll %.3f ms took %.3f ms: timeout',
timeout * 1e3, dt * 1e3)
else:
event_list = self._selector.select(timeout)
self._process_events(event_list)
# Handle 'later' callbacks that are ready.
end_time = self.time() + self._clock_resolution
for partition in self._p_to_process:
while self._partitions[partition].scheduled:
handle = self._partitions[partition].scheduled[0]
if handle._when >= end_time:
break
handle = heapq.heappop(self._partitions[partition].scheduled)
handle._scheduled = False
self._partitions[partition].handles.append(handle)
partitions = [
p for p in self._partitions if self._partitions[p].handles
]
ntodo = max(
[len(self._partitions[p].handles) for p in self._partitions])
cnt = 0
p_to_process = set()
handles_executed_per_partition = {p: 0 for p in self._partitions}
while not p_to_process and cnt < ntodo:
for partition in partitions:
try:
handle = self._partitions[partition].handles.popleft()
except IndexError:
if handles_executed_per_partition[partition] > 0:
p_to_process.add(partition)
continue
else:
handles_executed_per_partition[partition] += 1
if handle._cancelled:
continue
if self._debug:
try:
self._current_handle = handle
t0 = self.time()
handle._run()
dt = self.time() - t0
if dt >= self.slow_callback_duration:
logger.warning('Executing %s took %.3f seconds',
_format_handle(handle), dt)
finally:
self._current_handle = None
else:
handle._run()
cnt += 1
if p_to_process:
self._p_to_process = p_to_process
else:
# keep with the same ones, we didnt run the queues.
# FIXME : it can create starvation
pass
handle = None # Needed to break cycles when an exception occurs.
def load_default_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-011
Test Case: Check CDN by setting to BIOS Load default
Pass/Fail Criteria: 1. CDN setting should go to Defaut Value Disabled
2. Existing CDN Names should get retain
author: lakkris2
'''
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
bios_obj = cimc_util_obj.bios_util_obj
bios_token = 'cdnEnable'
cdn_token_enable = 'Enabled'
scope = 'advanced'
host_ip = get_host_mgmt_ip(config)
bios_obj.set_bios_token_value(bios_token, cdn_token_enable)
token_val = bios_obj.get_bios_token_value(bios_token)
if token_val == cdn_token_enable:
logger.info(
'Successfully verified that CDN token can be enabled from CIMC'
)
else:
self.failed('Failed to verify that CDN token,\
Expected is:' + cdn_token_enable + ' But got as: ' + token_val,
goto=[cleanup])
res = cimc_util_obj.verify_host_up(host_ip, wait_for_ping_fail=False)
if res is False:
logger.warning('Failed to ping the host after host reboot')
else:
logger.info("Host name IP pinging successfully")
test_fail = '0'
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
'''creating vNIC interface'''
dev_list = ['13']
if create_vnic_interface(self, vic_obj, slot_no,
dev_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
logger.info('Fetch VIC and CDN info before bios load defaults')
cdn_before_default = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_before_default is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
'''performing Bios default '''
if bios_obj.load_bios_defaults() is not True:
self.failed('Failed to run bios defaults', goto=['cleanup'])
res = cimc_util_obj.verify_host_up(host_ip,
wait_for_ping_fail=False,
wait_time=400)
if res is False:
logger.warning('Failed to ping the host after host reboot')
else:
logger.info("Host name IP pinging successfully")
'''After Bios Default checking CDN name and CDN setting '''
out = bios_obj.get_bios_token_value(bios_token)
if "Enabled" in out:
self.passed(
"CDN token Enabled after Loading Default bios setting")
else:
self.failed(
'Failed to Set CDN to Enabled after bios default, but got as:'
+ out)
logger.info('Fetch VIC and CDN info after bios load default')
cdn_after_default = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_after_disbale is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
test_fail = '0'
host_dict = vic_obj.host_cdn_mac_dict(cimc_util_obj.host_handle,
'biosdevname -d')
cdn_name_from_host = []
for cdn_name_from_host1 in host_dict.values():
cdn_name_from_host.append(cdn_name_from_host1)
if "LOMPort1" and "LOMPort2" not in cdn_name_from_host:
logger.info(
"LOMPort1 and LOMPort2 available in Host OS, when CDN Enabled"
)
else:
logger.error(
'LOMPort1 and LOMPort2 are not available in Host OS, when CDN Enabled'
)
test_fail = '1'
match = True
for key in cdn_before_default.keys():
if key in cdn_after_default.keys():
if cdn_before_default[key] != cdn_after_default[key]:
logger.error('CDN name Before:' +cdn_before_default[key] + \
'After Disable: ' + cdn_after_default[key])
match = False
else:
logger.info('CDN name before reboot:' +cdn_before_default[key] + \
'After Disable:' + cdn_after_default[key])
if match is True:
logger.info(
'CDN Name retained before and after bios load default')
else:
logger.info('Failed to retain Vnic after bios load default')
test_fail = '1'
mac_match = True
for mac in cdn_before_default.values():
if mac in cdn_after_default.values():
if cdn_before_default[mac] != cdn_after_default[mac]:
logger.error('CDN name Before:' +cdn_before_default[mac] + \
'After Disable: ' + cdn_after_default[mac])
mac_match = False
else:
logger.info('CDN name before reboot:' +cdn_before_default[mac] + \
'After Disable:' + cdn_after_default[mac])
if mac_match is True:
logger.info(
'CDN Name retained before and after bios load default')
else:
logger.info('Failed to retain Vnic after bios load default')
test_fail = '1'
if test_fail == '1':
self.failed('Test case failed')
else:
self.passed('Test case passed')
def _on_send(self, handle, error):
if error is not None:
logger.warning("error sending to UDP endpoint: {} - {}".format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
def _on_write(self, handle, error):
if error is not None:
logger.warning('error writing to connection: {} - {}'.format(error, pyuv.errno.strerror(error)))
exc = ConnectionError(error, pyuv.errno.strerror(error))
self._close(exc)
return
