def configure():
result_backend = RedisBackend(port=63791)
rabbitmq_broker = RabbitmqBroker(port=56721)
rabbitmq_broker.add_middleware(Results(backend=result_backend))
dramatiq.set_broker(rabbitmq_broker)
import argparse
import dramatiq
import requests
import sys
from dramatiq import group
from dramatiq.brokers.rabbitmq import RabbitmqBroker
from dramatiq.encoder import PickleEncoder
from dramatiq.results import Results
from dramatiq.results.backends import RedisBackend
encoder = PickleEncoder()
backend = RedisBackend(encoder=encoder)
broker = RabbitmqBroker()
broker.add_middleware(Results(backend=backend))
dramatiq.set_broker(broker)
dramatiq.set_encoder(encoder)
@dramatiq.actor
def request(uri):
return requests.get(uri)
@dramatiq.actor(store_results=True)
def count_words(response):
return len(response.text.split(" "))
def main():
parser = argparse.ArgumentParser()
from typing import List
from dacite import from_dict
from judger_error import JudgerError
from config import JUDGER_WORKSPACE, TEST_CASE_DIR
from compile_config import CompileConfig
from operation import Operation
from problem_info import ProblemInfo
from result import result
from run_config import RunConfig
from judger_task import Task
result_backend = RedisBackend(url="redis://container.ll-ap.cn:6379")
rabbitmq_broker = RabbitmqBroker(url="amqp://*****:*****@container.ll-ap.cn:5672")
rabbitmq_broker.add_middleware(Results(backend=result_backend))
# prometheus_middleware = Prometheus(http_host='0.0.0.0', http_port=9191)
# rabbitmq_broker.add_middleware(prometheus_middleware)
dramatiq.set_broker(rabbitmq_broker)
@dramatiq.actor(queue_name='judge', store_results=True)
def judge(task_id: str = None,
problem_id: str = None,
files: dict = None,
operations: List[str] = None,
config: dict = None):
if task_id is None or problem_id is None:
return
# Esse bloco (feio) faz com que esse módulo funcione dentro ou fora do Django
try:
from datasets.models import File
except ImproperlyConfigured:
import configurations
import os
os.environ.setdefault("DJANGO_CONFIGURATION", "Dev")
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "core.settings")
load_dotenv(find_dotenv())
configurations.setup()
from datasets.models import File
rabbitmq_broker = RabbitmqBroker(url=settings.BROKER_URL)
rabbitmq_broker.add_middleware(middleware.Prometheus())
set_broker(rabbitmq_broker)
client = get_s3_client(settings)
@actor(max_retries=5)
def content_from_file(file_pk=None, path=None, keep_file=True):
if not any([file_pk, path]):
raise Exception("Ou `file_pk` ou `path` devem ser informados.")
a_file = None
if file_pk:
a_file = File.objects.get(pk=file_pk)
if a_file.content is not None:
return a_file.content
from drama.config import settings
from drama.database import get_db_connection
from drama.logger import get_logger
from drama.manager import TaskManager
from drama.models.task import TaskResult, TaskStatus
from drama.process import Process
from drama.storage.helpers import get_available_storage
from drama.worker.helpers import get_process_func
logger = get_logger(__name__)
# setup broker
logger.debug("Setting up RabbitMQ broker")
broker = RabbitmqBroker(url=settings.RABBIT_DNS)
broker.add_middleware(CurrentMessage())
# set broker
logger.debug("Attaching broker")
dramatiq.set_broker(broker)
@dramatiq.actor(**settings.DEFAULT_ACTOR_OPTS.dict())
def process_task(task_request: dict):
"""
Main `drama` actor.
Executes an arbitrary function defined by a task and updates its state.
"""
message = CurrentMessage.get_current_message()
task_id = message.message_id
import os
from socket import gaierror
import dramatiq
from dramatiq.brokers.rabbitmq import RabbitmqBroker
import sentry_sdk
from persistence.database import db_session
from persistence.models import DomainName, get_or_create, SSLCheck
from ssl_checker import days_until_ssl_expiry
from tasks.middleware import SentryMiddleware
rabbitmq_broker = RabbitmqBroker(host='broker')
dramatiq.set_broker(rabbitmq_broker)
sentry_sdk.init(dsn=os.environ['SENTRY_DSN'])
rabbitmq_broker.add_middleware(SentryMiddleware(sentry_sdk.capture_exception))
LOG = logging.getLogger(__name__)
@dramatiq.actor
def days_until_ssl_expiry_job(hostname):
LOG.info('days_until_ssl_expiry_job')
try:
days_left = days_until_ssl_expiry(hostname)
except gaierror as e:
logging.error(f'Error processing job: {str(e)}')
return
# funky = 1 / 0 # TODO: ensure this gets to Sentry (import Sentry config at the top of this file?)
LOG.info(f'{hostname} SSL has {days_left} days until expiry')
app = Flask(__name__)
app.config.from_object(config)
collect = Collect(app)
broker = RabbitmqBroker(
host=config.RABBITMQ_HOST,
port=config.RABBITMQ_PORT,
credentials=PlainCredentials(config.RABBITMQ_USER,
config.RABBITMQ_PASSWORD),
heartbeat=5,
connection_attempts=5,
blocked_connection_timeout=30,
)
broker.add_middleware(handlers.AppContextDramatiqMiddleware(app))
dramatiq.set_broker(broker)
LazyActor.init_all_actors()
# DB session config
engine = create_engine(config.SQLALCHEMY_DATABASE_URI)
db_session_manager = scoped_session(sessionmaker(bind=engine))
# flask-login
login_manager = LoginManager(app)
login_manager.login_view = '/account/login/'
mail = Mail(app)
# registration blueprint
app.register_blueprint(bulls_and_cows_route.bulls_and_cows_blueprint)