def main():
args = parser.parse_args()
clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX))
# Чтобы логи не блокировали основной поток (и event loop) во время операций
# записи в stderr или файл - логи можно буфферизовать и обрабатывать в
# отдельном потоке (aiomisc.basic_config настроит буфферизацию
# автоматически).
basic_config(args.log_level, args.log_format, buffered=True)
# Аллоцируем сокет из под привиллегированного пользователя отдельным шагом,
# чтобы была возможность перед запуском приложения сменить пользователя ОС.
sock = bind_socket(
address=args.api_address,
port=args.api_port,
proto_name='http',
)
# После того как приложение аллоцировало сокет и ему больше не нужны
# привиллегии - хорошим решением будет сменить пользователя (например,
# на nobody, у которого нет никаких специальных привиллегий) - это также
# усложнит жизнь злоумышленникам.
if args.user is not None:
logging.info('Changing user to %r', args.user.pw_name)
os.setgid(args.user.pw_gid)
os.setuid(args.user.pw_uid)
# В списке процессов намного удобнее видеть название текущего приложения
setproctitle(os.path.basename(argv[0]))
app = create_app(args)
run_app(app, sock=sock)
def init_app(sub_apps: Dict[str, web.Application] = None):
"""
Main init routine.
:param sub_apps: the dictionary contains prefix: sub_app that should be appended to the main app
:return:
"""
args = get_args()
app = web.Application()
app["args"] = args
basic_config(level=log_level(args.log_level))
if sub_apps:
for prefix, sub_app in sub_apps.items():
app.add_subapp(prefix, sub_app)
app.add_routes([
web.get("/status", routes.status),
web.get("/tasks", routes.task_list),
web.post("/add_task", routes.add_task),
])
for st, cl in zip_longest(connection_routine.startup_callbacks,
connection_routine.cleanup_callbacks):
if st:
app.on_startup.append(st)
if cl:
app.on_cleanup.append(cl)
return app
def main():
global STORAGE
arguments = parser.parse_args()
basic_config(level=arguments.log_level,
log_format=arguments.log_format,
buffered=False)
setproctitle(os.path.basename("[Master] %s" % sys.argv[0]))
tcp_sock = bind_socket(address=arguments.tcp_listen,
port=arguments.tcp_port)
pickle_sock = bind_socket(address=arguments.pickle_listen,
port=arguments.pickle_port)
udp_sock = bind_socket(
socket.AF_INET6 if ':' in arguments.udp_listen else socket.AF_INET,
socket.SOCK_DGRAM,
address=arguments.udp_listen,
port=arguments.udp_port)
test_path = os.path.join(arguments.storage, '.test')
with open(test_path, 'ab+') as fp:
assert fp.truncate(0) == 0, ("Truncating not supported on %r" %
arguments.storage)
forkme.fork(arguments.forks)
setproctitle(os.path.basename("[Worker] %s" % sys.argv[0]))
loop = new_event_loop(arguments.pool_size)
loop.set_debug(arguments.debug)
basic_config(level=arguments.log_level,
log_format=arguments.log_format,
buffered=True,
loop=loop)
loop.create_task(amain(loop, tcp_sock, pickle_sock, udp_sock))
loop.create_task(
sender(arguments.carbon_proxy_url, arguments.carbon_proxy_secret))
STORAGE = Storage(os.path.join(arguments.storage,
"%03d.bin" % (forkme.get_id() or 0)),
loop=loop)
try:
loop.run_forever()
finally:
loop.stop()
loop.run_until_complete(loop.shutdown_asyncgens())
def main():
args = read_args_from_env().parse_args()
basic_config(args.log_level, args.log_format)
if args.user is not None:
logging.info('Changing user to %r', args.user.pw_name)
os.setgid(args.user.pw_gid)
os.setuid(args.user.pw_uid)
app = create_app()
web.run_app(app, host=args.http_address, port=args.http_port)
def test_configure_logging_json(capsys):
data = str(uuid.uuid4())
basic_config(level=logging.DEBUG, log_format='json', buffered=False)
logging.info(data)
time.sleep(0.3)
stdout, stderr = capsys.readouterr()
json_result = json.loads(stdout.strip())
assert json_result['msg'] == data
logging.basicConfig(handlers=[], level=logging.INFO)
def main():
arguments = parser.parse_args()
basic_config(level=arguments.log_level,
log_format=arguments.log_format,
buffered=False)
setproctitle(os.path.basename("[Master] %s" % sys.argv[0]))
tcp_sock = bind_socket(address=arguments.tcp_listen,
port=arguments.tcp_port)
pickle_sock = bind_socket(address=arguments.pickle_listen,
port=arguments.pickle_port)
udp_sock = bind_socket(
socket.AF_INET6 if ':' in arguments.udp_listen else socket.AF_INET,
socket.SOCK_DGRAM,
address=arguments.udp_listen,
port=arguments.udp_port)
def run():
setproctitle(os.path.basename("[Worker] %s" % sys.argv[0]))
storage = Storage(
os.path.join(arguments.storage, "%03d.db" % forklib.get_id()))
services = [
CarbonTCPServer(sock=tcp_sock, storage=storage),
CarbonPickleServer(sock=pickle_sock, storage=storage),
CarbonUDPServer(sock=udp_sock, storage=storage),
SenderService(
proxy_url=arguments.carbon_proxy_url,
secret=arguments.carbon_proxy_secret,
storage=storage,
interval=arguments.sender_interval,
chunk_size=arguments.chunk_size,
)
]
with entrypoint(*services,
log_level=arguments.log_level,
log_format=arguments.log_format,
pool_size=arguments.pool_size) as loop:
loop.set_debug(arguments.debug)
loop.run_forever()
if arguments.debug:
run()
else:
forklib.fork(arguments.forks, run)
def main():
arguments = parser.parse_args()
os.environ.clear()
basic_config(
level=arguments.log_level,
log_format=arguments.log_format,
buffered=False,
)
setproctitle(os.path.basename("[Master] %s" % sys.argv[0]))
sock = bind_socket(address=arguments.http_address,
port=arguments.http_port)
queue = deque()
services = [
API(
sock=sock,
password=arguments.http_password,
login=arguments.http_login,
queue=queue,
),
Sender(
jaeger_route=arguments.jaeger_route,
interval=arguments.sender_interval,
queue=queue,
),
]
if arguments.user is not None:
logging.info("Changing user to %r", arguments.user.pw_name)
os.setgid(arguments.user.pw_gid)
os.setuid(arguments.user.pw_uid)
def run():
setproctitle(os.path.basename("[Worker] %s" % sys.argv[0]))
with entrypoint(*services,
pool_size=arguments.pool_size,
log_level=arguments.log_level,
log_format=arguments.log_format,
debug=arguments.debug) as loop:
loop.run_forever()
if arguments.forks:
forklib.fork(arguments.forks, run, auto_restart=True)
else:
run()
def test_configure_logging_stderr(capsys):
data = str(uuid.uuid4())
out, err = capsys.readouterr()
# logging.basicConfig(level=logging.INFO)
basic_config(level=logging.DEBUG, log_format='stream', buffered=False)
logging.info(data)
time.sleep(0.3)
stdout, stderr = capsys.readouterr()
assert data in stderr
logging.basicConfig(handlers=[])
def main():
args = parser.parse_args()
config = load_config(args.config)
setproctitle(config["settings"]["proc_title"])
basic_config(level=config["settings"]["log_level"],
log_format='color',
flush_interval=2)
service = APIService(address=config["server"]["host"],
port=config["server"]["port"],
config=config)
with entrypoint(service) as loop:
loop.run_forever()
async def init_app(arguments: Namespace = None) -> web.Application:
args = arguments or get_args()
middlewares = [jwt_authorization] if not args.debug_token else list()
app = web.Application(middlewares=middlewares)
app["args"] = args
app["broker"] = RabbitClient(connection_string=args.amqp_connection, robust=False, pool=False,
ssl_options=ssl_options(),
exchange_name=AMQP_SETTINGS.get("topic_exchange_name"),
exchange_type=AMQP_SETTINGS.get("exchange_type"))
app["sessions"] = weakref.WeakSet()
basic_config(level=log_level(args.log_level))
app.add_routes([
web.get("/ws", ws_handler)
])
app.on_startup.append(init_services)
app.on_cleanup.append(cleanup)
return app
def main():
args = parser.parse_args()
sentry_sdk.init(dsn=args.sentry_dsn,
environment=args.sentry_environment,
integrations=[AioHttpIntegration()])
# Clear env variables of the app after start for security reasons.
# Clear variables that starts with ENV_VAR_PREFIX.
clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX))
# For processing logs in a separate thread.
basic_config(args.log_level, args.log_format, buffered=True)
setproctitle(os.path.basename(argv[0]))
app = create_app()
run_app(app, host=args.api_address, port=args.api_port)
def main():
global SECRET
arguments = parser.parse_args()
os.environ.clear()
basic_config(level=arguments.log_level,
log_format=arguments.log_format,
buffered=False)
setproctitle(os.path.basename("[Master] %s" % sys.argv[0]))
sock = bind_socket(address=arguments.http_address,
port=arguments.http_port)
services = [
API(
secret=arguments.http_secret,
sock=sock,
),
Sender(
routes=arguments.routes,
interval=arguments.sender_interval,
)
]
if arguments.user is not None:
logging.info('Changing user to %r', arguments.user.pw_name)
os.setgid(arguments.user.pw_gid)
os.setuid(arguments.user.pw_uid)
def run():
setproctitle(os.path.basename("[Worker] %s" % sys.argv[0]))
with entrypoint(*services,
pool_size=arguments.pool_size,
log_level=arguments.log_level,
log_format=arguments.log_format) as loop:
loop.set_debug(arguments.debug)
loop.run_forever()
if arguments.forks:
forklib.fork(arguments.forks, run, auto_restart=True)
else:
run()
def main():
args = parser.parse_args()
clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX))
basic_config(args.log_level, args.log_format, buffered=True)
train, test, item_features, item_feature_labels = fetch_dataset()
engine = create_engine(str(args.pg_url))
try:
with engine.begin() as conn:
fill_users_table(conn, train)
fill_items_table(conn, train)
fill_interactions_table(conn, train)
fill_interactions_table(conn, test)
fill_item_features_table(conn, item_features, item_feature_labels)
fill_item_descriptions_table(conn, item_features)
finally:
engine.dispose()
def main():
args = parser.parse_args()
clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX))
basic_config(args.log_level, args.log_format, buffered=True)
sock = bind_socket(address=args.api_address,
port=args.api_port,
proto_name='http')
if args.user is not None:
logging.info('Changing user to %r', args.user.pw_name)
os.setgid(args.user.pw_gid)
os.setuid(args.user.pw_uid)
setproctitle(os.path.basename(argv[0]))
app = create_app(args)
run_app(app, sock=sock)
def main():
args = parser.parse_args()
clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX))
basic_config(args.log_level, args.log_format, buffered=True)
# engine = create_engine(args.pg_url)
# try:
# with engine.begin() as conn:
users = fetch_active_users()
items = fetch_latest_items()
train, test, user_features, item_features = fetch_training_data()
# finally:
# engine.dispose()
model = train_model(train, test, user_features, item_features)
predictions = predict(model, users, items, user_features, item_features)
with Redis.from_url(str(args.redis_url)) as r:
cache_predictions(r, predictions, args.redis_ttl)
cache_latest_items(r, items[:100], args.redis_ttl)
def main():
global SECRET
arguments = parser.parse_args()
basic_config(level=arguments.log_level,
log_format=arguments.log_format,
buffered=False)
setproctitle(os.path.basename("[Master] %s" % sys.argv[0]))
sock = bind_socket(address=arguments.http_address,
port=arguments.http_port)
forkme.fork(arguments.forks)
setproctitle(os.path.basename("[Worker] %s" % sys.argv[0]))
SECRET = arguments.http_secret
loop = new_event_loop(arguments.pool_size)
loop.set_debug(arguments.debug)
app = make_app(arguments)
app._debug = arguments.debug
app.on_startup.append(setup_routes)
app.on_startup.append(partial(setup_sender, arguments=arguments))
log.info("Starting application http://%s:%d", arguments.http_address,
arguments.http_port)
basic_config(level=arguments.log_level,
log_format=arguments.log_format,
buffered=True,
loop=loop)
try:
run_app(sock=sock, loop=loop, app=app, print=log.debug)
except GracefulExit:
log.info("Exiting")
def main():
args = parser.parse_args()
# После получения конфигурации приложения переменные окружения приложения
# больше не нужны и даже могут представлять опасность - например, они могут
# случайно "утечь" с отображением информации об ошибке. Злоумышленники
# в первую очередь будут пытаться получить информацию об окружении, очистка
# переменных окружения считается хорошим тоном.
# Python позволяет управлять поведением stdlib модулей с помощью
# многочисленных переменных окружения, разумно очищать переменные окружения
# по префиксу приложения, указанного в ConfigArgParser.
clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX))
# Чтобы логи не блокировали основной поток (и event loop) во время операций
# записи в stderr или файл - логи можно буфферизовать и обрабатывать в
# отдельном потоке (aiomisc.basic_config настроит буфферизацию
# автоматически).
basic_config(args.log_level, args.log_format, buffered=True)
# Аллоцируем сокет из под привиллегированного пользователя отдельным шагом,
# чтобы была возможность перед запуском приложения сменить пользователя ОС.
sock = bind_socket(address=args.api_address,
port=args.api_port,
proto_name='http')
# После того как приложение аллоцировало сокет и ему больше не нужны
# привиллегии - хорошим решением будет сменить пользователя (например,
# на nobody, у которого нет никаких специальных привиллегий) - это также
# усложнит жизнь злоумышленникам.
if args.user is not None:
logging.info('Changing user to %r', args.user.pw_name)
os.setgid(args.user.pw_gid)
os.setuid(args.user.pw_uid)
# В списке процессов намного удобнее видеть название текущего приложения
setproctitle(os.path.basename(argv[0]))
app = create_app(args)
run_app(app, sock=sock)
def main():
from aiomisc.log import basic_config
debug = True
basic_config(logging.DEBUG, buffered=True)
loop = asyncio.get_event_loop()
# logging.basicConfig(level=logging.DEBUG if debug else logging.INFO)
reload = False
while True:
bot_loop_task = asyncio.ensure_future(bot_loop())
try:
if reload:
loop.run_until_complete(
run_with_reloader(loop, bot_loop_task, bot.stop))
else:
loop.run_until_complete(bot_loop_task)
# User cancels
except KeyboardInterrupt:
logger.debug("User cancelled")
bot_loop_task.cancel()
bot.stop()
break
# Stop loop
finally:
if AIOHTTP_23:
loop.run_until_complete(bot.session.close())
logger.debug("Closing loop")
loop.stop()
loop.close()
def main():
args = parser.parse_args()
# После получения конфигурации приложения переменные окружения приложения
# больше не нужны и даже могут представлять опасность - например, они могут
# случайно "утечь" с отображением информации об ошибке. Злоумышленники
# в первую очередь будут пытаться получить информацию об окружении, очистка
# переменных окружения считается хорошим тоном.
# Python позволяет управлять поведением stdlib модулей с помощью
# многочисленных переменных окружения, разумно очищать переменные окружения
# по префиксу приложения, указанного в ConfigArgParser.
clean_environ(rule=lambda var: var.startswith(ENV_VAR_PREFIX))
# Чтобы логи не блокировали основной поток (и event loop) во время операций
# записи в stderr или файл - логи можно буфферизовать и обрабатывать в
# отдельном потоке (aiomisc.basic_config настроит буфферизацию
# автоматически).
basic_config(level=args.log_level,
log_format=args.log_format,
buffered=True)
app = create_app(args=args)
web.run_app(app=app, host=args.api_address, port=args.api_port)
from config import AppConfig
import logging
from aiomisc.log import basic_config
from aiohttp.web import Application
basic_config(AppConfig.LOGGING, buffered=True)
logger = logging.getLogger("api_logger")
host = AppConfig.HOST
port = AppConfig.PORT
app = Application(client_max_size=AppConfig.MAX_REQUEST_SIZE)
def main() -> None:
address: Union[str, Tuple[str, int]]
cookie: bytes
identity: str
(address, cookie, identity, log_level,
log_format) = pickle.load(sys.stdin.buffer)
basic_config(level=log_level, log_format=log_format)
family = (socket.AF_UNIX if isinstance(address, str) else INET_AF)
with socket.socket(family, socket.SOCK_STREAM) as sock:
logging.debug("Connecting...")
sock.connect(address)
def send(packet_type: PacketTypes, data: Any) -> None:
payload = pickle.dumps(data)
sock.send(Header.pack(packet_type.value, len(payload)))
sock.send(payload)
def receive() -> Tuple[PacketTypes, Any]:
header = sock.recv(Header.size)
if not header:
raise ValueError("No data")
packet_type, payload_length = Header.unpack(header)
payload = sock.recv(payload_length)
return PacketTypes(packet_type), pickle.loads(payload)
def auth(cookie: bytes) -> None:
hasher = HASHER()
salt = urandom(SALT_SIZE)
send(PacketTypes.AUTH_SALT, salt)
hasher.update(salt)
hasher.update(cookie)
send(PacketTypes.AUTH_DIGEST, hasher.digest())
packet_type, value = receive()
if packet_type == PacketTypes.AUTH_OK:
return value
raise RuntimeError(PacketTypes(packet_type), value)
def step() -> bool:
try:
packet_type, (func, args, kwargs) = receive()
except ValueError:
return True
if packet_type == packet_type.REQUEST:
response_type = PacketTypes.RESULT
try:
result = func(*args, **kwargs)
except Exception as e:
response_type = PacketTypes.EXCEPTION
result = e
logging.exception("Exception when processing request")
send(response_type, result)
return False
logging.debug("Starting authorization")
auth(cookie)
del cookie
send(PacketTypes.IDENTITY, identity)
logging.debug("Worker ready")
try:
while not step():
pass
except KeyboardInterrupt:
return
import os
import asyncio
import aiohttp
from aiohttp import web
import socket
import logging
import json
from motor.motor_asyncio import AsyncIOMotorClient
from bson import json_util
from aiomisc.log import LogFormat, LogLevel, basic_config
basic_config(LogLevel.info, LogFormat.color, buffered=True)
log = logging.getLogger(__name__)
class WebSocketHandler:
def __init__(self, url: str, db_client, loop=None) -> None:
self.url = url
self.loop = loop or asyncio.get_event_loop()
self.session = None
self.websocket = None
self.client = db_client
self.db = self.client.get_database()
async def connect(self):
conn = aiohttp.TCPConnector(
family=socket.AF_INET,
ssl=False,
)
self.session = aiohttp.ClientSession(loop=self.loop,
import asyncio
import logging
from aiohttp import web
from aiomisc.service.aiohttp import AIOHTTPService
from aiomisc import entrypoint
from aiomisc.log import basic_config
from routes import setup_routes
from views import update_rate
log = logging.getLogger(__name__)
basic_config(
level=logging.INFO,
log_format='color',
buffered=False,
buffer_size=1024,
)
async def start_background_tasks(app):
app['rate_updater'] = asyncio.create_task(update_rate(app))
log.info("Background task are created")
async def cleanup_background_tasks(app):
app['rate_updater'].cancel()
log.info("Background task are cancelled")
await app['rate_updater']
from aiomisc.log import basic_config import logging from .app import run_services basic_config(level=logging.INFO, buffered=True, log_format='color') name = 'exchanges_rates_async'
import logging
from aiomisc.log import basic_config
basic_config(level=logging.INFO, buffered=False, log_format='json')
log = logging.getLogger('service')
