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