def __init__(self, **kwargs):
self.cfg = AutoCFG(
{k: kwargs.get(k, v)
for k, v in ABSTRACT_AEON_DEFAULTS.items()})
if self.cfg.loop is None:
self.cfg.loop = asyncio.get_event_loop()
self._contexts = {}
if self.cfg.ssl is None and self.cfg.certs:
for host in self.cfg.certs:
context = ssl.create_default_context(
purpose=ssl.Purpose.CLIENT_AUTH,
cafile=self.cfg.ca_cert,
)
context.load_cert_chain(
certfile=self.cfg.certs[host]['certfile'],
keyfile=self.cfg.certs[host]['keyfile'],
password=self.cfg.certs[host].get('keypassword', None),
)
self._contexts[host] = context
self.cfg.ssl = ssl.create_default_context(
purpose=ssl.Purpose.CLIENT_AUTH,
cafile=self.cfg.ca_cert,
)
self.cfg.ssl.set_servername_callback(self.servername_callback)
self._task = None
self._server = None
self._logger = logger.new_channel(
key='aeon',
parent=logger.get_channel('base_logger'),
**self.cfg.logger,
)
self.running_tasks = []
async def __aenter__(self):
await self._open()
self._logger = new_channel(
key=f'aeon-client-{hexlify(urandom(2)).decode()}',
parent=ClientLogger,
)
return self
def __init__(self, addr, reader, writer, **kwargs):
self.__start_time = time.time()
self._initialized = False
self.cfg = AutoCFG(self.defaults).update_fields(kwargs)
self.logger = logger.new_channel(f'{addr[0]}:{addr[1]}', parent='aeon')
self._addr = addr
self._reader = reader
self._writer = writer
self._source_ip = self._addr[0]
self.port = self._addr[1]
self.keep_alive = True
self._real_ip = self._addr
self._url = None
self._args = {}
self._method = None
self._http_version = None
self._headers = {}
self._data = b''
self._ssl = kwargs.get('ssl', False)
self._send = False
self._callback = {
'before_send': [],
'after_send': [],
}
def __init__(self, target, **kwargs):
if not (callable(target) or asyncio.iscoroutinefunction(target)):
raise TypeError('target must be callable or async coroutine')
self._cfg = AutoCFG(TASK_DEFAULTS).deep_update_fields(kwargs)
self._target = target
self._offset = (self._cfg.offset['hour'] * 60 +
self._cfg.offset['min']) * 60 + self._cfg.offset['sec']
self._inter = (self._cfg.interval['hour'] * 60 + self._cfg.
interval['min']) * 60 + self._cfg.interval['sec']
self.logger = logger.new_channel('planner_task_{}'.format(
self._cfg.key),
parent='planner')
self._shedule = []
quote,
quote_from_bytes,
urlencode,
)
from k2.utils.autocfg import AutoCFG
from k2.utils.http import HTTP_CODE_MSG
from k2.aeon.parser import parse_response_data
from k2.logger import (
new_channel,
get_channel,
delete_channel,
)
ClientLogger = new_channel(
key='aeon-client',
parent=get_channel('aeon') or get_channel('base_logger'),
)
class BaseHTTPSession:
defaults = {
'timeout': None,
}
def __init__(self, host, port, ssl=False, limit=None, loop=None, **kwargs):
self._conn_args = {
'host': host,
'port': port,
'ssl': ssl,
**{k: v
from unittest import TestCase
import asyncio
from k2.logger import new_channel
from k2.aeon import ScriptRunner
LOOP = asyncio.get_event_loop()
LOGGER = new_channel('test')
class TestScriptRunner(TestCase):
def do_test(self, corotine, error=False, **kwargs):
try:
return LOOP.run_until_complete(corotine)
except Exception:
self.assertTrue(error)
def test_empty(self):
sr = ScriptRunner(text='', args={}, logger=LOGGER)
self.assertTrue(self.do_test(sr.run()))
self.assertEqual(sr.export(), '')
def test_simple_none(self):
sr = ScriptRunner(text='123 smth 1231', args={}, logger=LOGGER)
self.assertTrue(self.do_test(sr.run()))
self.assertEqual(sr.export(), '123 smth 1231')
def test_simple_some(self):
sr = ScriptRunner(text='/*# "123" #*/', args={}, logger=LOGGER)
self.assertTrue(self.do_test(sr.run()))
self.assertEqual(sr.export(), '123')