def main(*argv): parser = ArgumentParser(usage=USAGE) parser.add_argument("-v", "--verbose", action='store_true', default=False, help="more verbose output") parser.add_argument("-n", "--dry-run", action='store_true', default=False, help="DEBUG ONLY: minimal interactions with node," " that are expected to be ON;" "won't check on and off and reset; " "won't load any image on node") parser.add_argument("-s", "--speedy", action='store_true', default=False, help="DEBUG ONLY: will only load one image") add_selector_arguments(parser) args = parser.parse_args(argv) selector = selected_selector(args, defaults_to_all=True) nightly = Nightly(selector, dry_run=args.dry_run, verbose=args.verbose, speedy=args.speedy) # turn off asyncssh info message unless verbose if not args.verbose: set_log_level(logging.ERROR) return 0 if nightly.run() else 1
async def _remote_connection(self, host: str, addr: Optional[str] = None, ) -> "SSHClientConnection": if not self.cons.get(host): if not addr and host in self.mgr.inventory: addr = self.mgr.inventory.get_addr(host) if not addr: raise OrchestratorError("host address is empty") assert self.mgr.ssh_user n = self.mgr.ssh_user + '@' + addr logger.debug("Opening connection to {} with ssh options '{}'".format( n, self.mgr._ssh_options)) asyncssh.set_log_level('DEBUG') asyncssh.set_debug_level(3) with self.redirect_log(host, addr): try: conn = await asyncssh.connect(addr, username=self.mgr.ssh_user, client_keys=[self.mgr.tkey.name], known_hosts=None, config=[self.mgr.ssh_config_fname], preferred_auth=['publickey']) except OSError: raise except asyncssh.Error: raise except Exception: raise self.cons[host] = conn self.mgr.offline_hosts_remove(host) conn = self.cons.get(host) return conn
def test_logging(self): """Test AsyncSSH logging""" asyncssh.set_log_level('INFO') with self.assertLogs(level='INFO') as log: logger.info('Test') self.assertEqual(len(log.records), 1) self.assertEqual(log.records[0].msg, 'Test')
def test_connection_log(self): """Test connection-level logger""" asyncssh.set_log_level('INFO') with (yield from self.connect()) as conn: with self.assertLogs(level='INFO') as log: conn.logger.info('Test') self.assertEqual(len(log.records), 1) self.assertRegex(log.records[0].msg, r'\[conn=\d+\] Test')
async def start_server(): asyncssh.set_log_level('DEBUG') asyncssh.set_debug_level(2) await asyncssh.create_server(MySSHServer, '', 8022, server_host_keys=[ '/etc/ssh/ssh_host_ecdsa_key', '/etc/ssh/ssh_host_rsa_key', ], process_factory=handle_client)
def test_packet_logging(self): """Test packet logging""" asyncssh.set_log_level('DEBUG') asyncssh.set_debug_level(3) with self.assertLogs(level='DEBUG') as log: logger.packet(0, bytes(range(0x10, 0x30)), 'CONTROL') self.assertEqual(log.records[0].msg, '[pktid=0] CONTROL\n' + ' 00000000: 10 11 12 13 14 15 16 17 18 ' + '19 1a 1b 1c 1d 1e 1f ................\n' + ' 00000010: 20 21 22 23 24 25 26 27 28 ' + '29 2a 2b 2c 2d 2e 2f !"#$%%&\'()*+,-./')
def main(): """Run server here.""" for logger in [ logging.getLogger(name) for name in logging.root.manager.loggerDict ]: logger.setLevel(logging.DEBUG) logging.basicConfig(level=logging.DEBUG) asyncssh.set_log_level("DEBUG") loop = asyncio.get_event_loop() loop.run_until_complete( start_server(ServerConfig.load(prefix="here"), namespace={})) loop.run_forever()
def test_stream_log(self): """Test stream-level logger""" asyncssh.set_log_level('INFO') with (yield from self.connect()) as conn: stdin, _, _ = yield from conn.open_session() with self.assertLogs(level='INFO') as log: stdin.logger.info('Test') stdin.write_eof() yield from stdin.channel.wait_closed() self.assertEqual(len(log.records), 1) self.assertRegex(log.records[0].msg, r'\[conn=\d+, chan=0\] Test')
def main(args): """ Entry Point """ global ca, config logging.basicConfig() config = json.load(open(args.config, 'r')) asyncssh.set_log_level(config.get('loglevel', 10)) ca = load_ca(config['ca']) loop = asyncio.get_event_loop() try: loop.run_until_complete(start_server()) except (OSError, asyncssh.Error) as exc: sys.exit('Error starting server: ' + str(exc)) loop.run_forever()
def test_channel_log(self): """Test channel-level logger""" asyncssh.set_log_level('INFO') with (yield from self.connect()) as conn: for i in range(2): chan, _ = yield from conn.create_session(SSHClientSession) with self.assertLogs(level='INFO') as log: chan.logger.info('Test') chan.write_eof() yield from chan.wait_closed() self.assertEqual(len(log.records), 1) self.assertRegex(log.records[0].msg, r'\[conn=\d+, chan=%s\] Test' % i)
def test_debug_levels(self): """Test log debug levels""" asyncssh.set_log_level('DEBUG') for debug_level in range(1, 4): with self.subTest(debug_level=debug_level): asyncssh.set_debug_level(debug_level) with self.assertLogs(level='DEBUG') as log: logger.debug1('DEBUG') logger.debug2('DEBUG') logger.packet(None, b'', 'DEBUG') self.assertEqual(len(log.records), debug_level) for record in log.records: self.assertEqual(record.msg, record.levelname)
def test_process_log(self): """Test process-level logger""" asyncssh.set_log_level('INFO') with (yield from self.connect()) as conn: process = yield from conn.create_process() with self.assertLogs(level='INFO') as log: process.logger.info('Test') process.stdin.write_eof() yield from process.wait() asyncssh.set_log_level('WARNING') self.assertEqual(len(log.records), 1) self.assertRegex(log.records[0].msg, r'\[conn=\d+, chan=0\] Test')
except ImportError: try: from colored import bg BACK_RESET = bg(0) BACK_BLUE = bg(27) BACK_GREEN = bg(119) except ImportError: BACK_RESET = '' BACK_BLUE = '' BACK_GREEN = '' # https://www.pythoncentral.io/sqlalchemy-orm-examples/ # db = sqlite3.connect('session.db') logging.getLogger().setLevel(logging.DEBUG) asyncssh.set_log_level(logging.DEBUG) log = logging.getLogger('sshame') asyncssh.set_debug_level(2) def configure_logging(): global log # logging.getLogger("asyncssh").setLevel(logging.DEBUG) # logging.getLogger("asyncio").setLevel(logging.DEBUG) log.setLevel(logging.DEBUG) # create file handler which logs even debug messages fh = logging.FileHandler('sshame.log') fh.setLevel(logging.DEBUG) # create console handler with a higher log level ch = logging.StreamHandler() ch.setLevel(logging.INFO)
"""Module for connections.""" import asyncio import logging from asyncio import LimitOverrunError, TimeoutError import asyncssh _LOGGER = logging.getLogger(__name__) _PATH_EXPORT_COMMAND = "PATH=$PATH:/bin:/usr/sbin:/sbin" asyncssh.set_log_level('WARNING') class SshConnection: """Maintains an SSH connection to an ASUS-WRT router.""" def __init__(self, host, port, username, password, ssh_key): """Initialize the SSH connection properties.""" self._connected = False self._host = host self._port = port or 22 self._username = username self._password = password self._ssh_key = ssh_key self._client = None async def async_run_command(self, command, retry=False): """Run commands through an SSH connection. Connect to the SSH server if not currently connected, otherwise use the existing connection.
"""Module for connections.""" import asyncio from asyncio import IncompleteReadError import logging from asyncio import LimitOverrunError, TimeoutError from math import floor import asyncssh _LOGGER = logging.getLogger(__name__) _PATH_EXPORT_COMMAND = "PATH=$PATH:/bin:/usr/sbin:/sbin" asyncssh.set_log_level("WARNING") class SshConnection: """Maintains an SSH connection to an ASUS-WRT router.""" def __init__(self, host, port, username, password, ssh_key): """Initialize the SSH connection properties.""" self._host = host self._port = port or 22 self._username = username self._password = password self._ssh_key = ssh_key self._client = None async def async_run_command(self, command, retry=False): """Run commands through an SSH connection. Connect to the SSH server if not currently connected, otherwise use the existing connection. """
from container import ContainerPool from sshserver import SSHServer # logging config logging.basicConfig( level=logging.INFO, format='%(asctime)-18s %(name)-20s %(levelname)-8s %(message)s', datefmt='%d-%m %H:%M:%S', handlers=[ logging.FileHandler("sshproxy.log", mode='w'), logging.StreamHandler() ]) main_logger = logging.getLogger('main') main_logger.setLevel(logging.INFO) asyncssh.set_log_level(logging.WARNING) # async ssh setup os.environ['PYLXD_WARNINGS'] = 'none' # config setup container_pool_config = json.load(open('config/container_pool.json')) container_ssh_config = json.load(open('config/container_ssh.json')) container_config = json.load(open('config/container.json')) # pool creation pool = ContainerPool(container_pool_config, container_config) # async io loop loop = asyncio.get_event_loop()
import asyncio import asyncssh import asyncpg import logging asyncssh.set_log_level(40) logging.basicConfig( filename='pirit_info.log', level=logging.INFO, format='%(message)s', datefmt='%Y-%m-%d %H:%M:%S' ) def message(command, data): """ Формирует пакет для ККМ @params: command - Команда, 2 символа (str) data - Данные, разденены запятой (str) """ data = [x for x in data] for n, i in enumerate(data): if i == ',': data[n] = 28 continue data[n] = ord(i) frame = bytearray() frame += 'PIRI'.encode() # пароль frame.append(0x21) # id пакета frame.append(ord(command[0])) # первый байт команды