async def _load_agent(
model_path: Optional[Text] = None,
model_server: Optional[EndpointConfig] = None,
remote_storage: Optional[Text] = None,
endpoints: Optional[AvailableEndpoints] = None,
lock_store: Optional[LockStore] = None,
) -> Agent:
try:
tracker_store = None
generator = None
action_endpoint = None
if endpoints:
broker = EventBroker.create(endpoints.event_broker)
tracker_store = TrackerStore.create(endpoints.tracker_store,
event_broker=broker)
generator = endpoints.nlg
action_endpoint = endpoints.action
if not lock_store:
lock_store = LockStore.create(endpoints.lock_store)
loaded_agent = await load_agent(
model_path,
model_server,
remote_storage,
generator=generator,
tracker_store=tracker_store,
lock_store=lock_store,
action_endpoint=action_endpoint,
)
except Exception as e:
logger.debug(traceback.format_exc())
raise ErrorResponse(500, "LoadingError",
f"An unexpected error occurred. Error: {e}")
if not loaded_agent:
raise ErrorResponse(
400,
"BadRequest",
f"Agent with name '{model_path}' could not be loaded.",
{
"parameter": "model",
"in": "query"
},
)
return loaded_agent
def test_sql_broker_logs_to_sql_db():
cfg = read_endpoint_config(
"data/test_endpoints/event_brokers/sql_endpoint.yml", "event_broker")
actual = EventBroker.create(cfg)
assert isinstance(actual, SQLEventBroker)
for e in TEST_EVENTS:
actual.publish(e.as_dict())
with actual.session_scope() as session:
events_types = [
json.loads(event.data)["event"]
for event in session.query(actual.SQLBrokerEvent).all()
]
assert events_types == ["user", "slot", "restart"]
def test_file_broker_logs_to_file(tmpdir):
log_file_path = tmpdir.join("events.log").strpath
actual = EventBroker.create(
EndpointConfig(**{"type": "file", "path": log_file_path})
)
for e in TEST_EVENTS:
actual.publish(e.as_dict())
# reading the events from the file one event per line
recovered = []
with open(log_file_path, "r") as log_file:
for line in log_file:
recovered.append(Event.from_parameters(json.loads(line)))
assert recovered == TEST_EVENTS
def test_file_broker_properly_logs_newlines(tmpdir):
log_file_path = tmpdir.join("events.log").strpath
actual = EventBroker.create(
EndpointConfig(**{"type": "file", "path": log_file_path})
)
event_with_newline = UserUttered("hello \n there")
actual.publish(event_with_newline.as_dict())
# reading the events from the file one event per line
recovered = []
with open(log_file_path, "r") as log_file:
for line in log_file:
recovered.append(Event.from_parameters(json.loads(line)))
assert recovered == [event_with_newline]
def create_agent(model: Text, endpoints: Text = None) -> "Agent":
from rasa.core.tracker_store import TrackerStore
from rasa.core.utils import AvailableEndpoints
from rasa.core.agent import Agent
from rasa.core.brokers.broker import EventBroker
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
_broker = EventBroker.create(_endpoints.event_broker)
_tracker_store = TrackerStore.create(_endpoints.tracker_store, event_broker=_broker)
_lock_store = LockStore.create(_endpoints.lock_store)
return Agent.load(
model,
generator=_endpoints.nlg,
tracker_store=_tracker_store,
lock_store=_lock_store,
action_endpoint=_endpoints.action,
)
def _get_event_broker(endpoints: "AvailableEndpoints") -> Optional["EventBroker"]:
"""Get `EventBroker` from `endpoints`.
Prints an error and exits if no event broker could be loaded.
Args:
endpoints: `AvailableEndpoints` to initialize the event broker from.
Returns:
Initialized event broker.
"""
if not endpoints.event_broker:
cli_utils.print_error_and_exit(
f"Could not find an `event_broker` section in the supplied "
f"endpoints file. Instructions on how to configure an event broker "
f"can be found here: {DOCS_URL_EVENT_BROKERS}. Exiting."
)
from rasa.core.brokers.broker import EventBroker
return EventBroker.create(endpoints.event_broker)
def test_no_broker_in_config():
cfg = read_endpoint_config(DEFAULT_ENDPOINTS_FILE, "event_broker")
actual = EventBroker.create(cfg)
assert actual is None
def test_load_non_existent_custom_broker_name():
config = EndpointConfig(**{"type": "rasa.core.brokers.my.MyProducer"})
assert EventBroker.create(config) is None
def test_load_custom_broker_name():
config = EndpointConfig(**{"type": "rasa.core.brokers.file.FileEventBroker"})
assert EventBroker.create(config)
async def load_agent_on_start(
model_path: Text,
endpoints: AvailableEndpoints,
remote_storage: Optional[Text],
app: Sanic,
loop: AbstractEventLoop,
):
"""Load an agent.
Used to be scheduled on server start
(hence the `app` and `loop` arguments)."""
# noinspection PyBroadException
try:
with model.get_model(model_path) as unpacked_model:
_, nlu_model = model.get_model_subdirectories(unpacked_model)
_interpreter = rasa.core.interpreter.create_interpreter(
endpoints.nlu or nlu_model)
except Exception:
logger.debug(f"Could not load interpreter from '{model_path}'.")
_interpreter = None
_broker = EventBroker.create(endpoints.event_broker)
_tracker_store = TrackerStore.create(endpoints.tracker_store,
event_broker=_broker)
_lock_store = LockStore.create(endpoints.lock_store)
model_server = endpoints.model if endpoints and endpoints.model else None
try:
app.agent = await agent.load_agent(
model_path,
model_server=model_server,
remote_storage=remote_storage,
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
lock_store=_lock_store,
action_endpoint=endpoints.action,
)
except Exception as e:
rasa.shared.utils.io.raise_warning(
f"The model at '{model_path}' could not be loaded. "
f"Error: {e}")
app.agent = None
if not app.agent:
rasa.shared.utils.io.raise_warning(
"Agent could not be loaded with the provided configuration. "
"Load default agent without any model.")
app.agent = Agent(
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action,
model_server=model_server,
remote_storage=remote_storage,
)
logger.info("Rasa server is up and running.")
return app.agent
