async def test_EVENT_AMT_MODIFIED(system):
handler = TestEventHandler()
await system.register_event_handler(EVENT_AMT_MODIFIED, handler)
amt = AnalysisModuleType("test", "")
await system.register_analysis_module_type(amt)
assert handler.event is None
handler = TestEventHandler()
await system.register_event_handler(EVENT_AMT_MODIFIED, handler)
# still not modified yet
await system.register_analysis_module_type(amt)
assert handler.event is None
# modify version
amt.version = "1.0.1"
handler = TestEventHandler()
await system.register_event_handler(EVENT_AMT_MODIFIED, handler)
# modified this time
await system.register_analysis_module_type(amt)
await handler.wait()
assert handler.event.name == EVENT_AMT_MODIFIED
assert AnalysisModuleType.from_dict(handler.event.args) == amt
def from_dict(value: dict,
system: "ace.system.ACESystem") -> "AnalysisRequest":
assert isinstance(value, dict)
data = AnalysisRequestModel(**value)
root = None
if isinstance(data.root, RootAnalysisModel):
root = RootAnalysis.from_dict(data.root.dict(), system=system)
observable = None
if data.observable:
observable = Observable.from_dict(data.observable.dict(), root)
observable = root.get_observable(observable)
type = None
if data.type:
type = AnalysisModuleType.from_dict(data.type.dict())
ar = AnalysisRequest(system, root, observable, type)
ar.id = data.id
# ar.dependency_analysis = json_data["dependency_analysis"]
ar.status = data.status
ar.owner = data.owner
if data.original_root:
ar.original_root = RootAnalysis.from_dict(
data.original_root.dict(), system)
if data.modified_root:
ar.modified_root = RootAnalysis.from_dict(
data.modified_root.dict(), system)
return ar
async def register_analysis_module_type(
self, amt: AnalysisModuleType) -> AnalysisModuleType:
assert isinstance(amt, AnalysisModuleType)
async with self.get_client() as client:
response = await client.post("/amt", json=amt.to_dict())
_raise_exception_on_error(response)
return AnalysisModuleType.from_dict(response.json())
async def i_get_all_analysis_module_types(
self) -> list[AnalysisModuleType]:
async with self.get_db() as db:
return [
AnalysisModuleType.from_dict(json.loads(_[0].json_data))
for _ in (
await db.execute(select(AnalysisModuleTracking))).all()
]
async def get_analysis_module_type(
self, name: str) -> Union[AnalysisModuleType, None]:
assert isinstance(name, str) and name
async with self.get_client() as client:
response = await client.get(f"/amt/{name}")
_raise_exception_on_error(response)
if response.status_code == 404:
return None
return AnalysisModuleType.from_dict(response.json())
async def i_get_analysis_module_type(
self, name: str) -> Union[AnalysisModuleType, None]:
async with self.get_db() as db:
db_amt = (await db.execute(
select(AnalysisModuleTracking).where(
AnalysisModuleTracking.name == name))).scalar()
if db_amt is None:
return None
return AnalysisModuleType.from_dict(json.loads(db_amt.json_data))
def test_analysis_module_type_serialization():
amt = AnalysisModuleType(
name="test",
description="test",
observable_types=["test1", "test2"],
directives=["test1", "test2"],
dependencies=["test1", "test2"],
tags=["test1", "test2"],
modes=["test1", "test2"],
cache_ttl=60,
extended_version={"test1": "test2"},
types=["test1", "test2"],
)
assert amt == AnalysisModuleType.from_dict(amt.to_dict())
assert amt == AnalysisModuleType.from_json(amt.to_json())
async def test_EVENT_AMT_DELETED(system):
handler = TestEventHandler()
await system.register_event_handler(EVENT_AMT_DELETED, handler)
amt = AnalysisModuleType("test", "")
await system.register_analysis_module_type(amt)
await system.delete_analysis_module_type(amt)
await handler.wait()
assert handler.event.name == EVENT_AMT_DELETED
assert AnalysisModuleType.from_dict(handler.event.args) == amt
handler = TestEventHandler()
await system.register_event_handler(EVENT_AMT_DELETED, handler)
await system.delete_analysis_module_type(amt)
assert handler.event is None
async def test_EVENT_AMT_NEW(system):
handler = TestEventHandler()
await system.register_event_handler(EVENT_AMT_NEW, handler)
amt = AnalysisModuleType("test", "")
await system.register_analysis_module_type(amt)
await handler.wait()
assert handler.event.name == EVENT_AMT_NEW
assert AnalysisModuleType.from_dict(handler.event.args) == amt
handler = TestEventHandler()
await system.register_event_handler(EVENT_AMT_NEW, handler)
# already registered so should not be new
await system.register_analysis_module_type(amt)
assert handler.event is None
async def api_register_analysis_module_type(amt: AnalysisModuleTypeModel):
try:
result = await app.state.system.register_analysis_module_type(AnalysisModuleType.from_dict(amt.dict()))
return result.to_dict()
except ACEError as e:
return JSONResponse(status_code=400, content=ErrorModel(code=e.code, details=str(e)).dict())
