mainframe.scan_cache¶

Optional cache storage: bounded batches, immutable results, isolated DB pool.

Attributes¶

`quarantined_entries`
`requests`
`latency`
`rows_written`
`rows_renewed`
`cache_size`
`cache_entries`
`cache_payload`
`rows_expired`
`admission_skips`
`_gate`
`_rate_lock`
`_recent_requests`
`MAX_REQUESTS_PER_SECOND`
`MAX_NAMESPACES`
`CLEANUP_BATCH`

Functions¶

`cache_engine`(→ sqlalchemy.Engine)	Reserve at most one connection per API process, outside the queue pool.
`require_cache`(→ None)
`cache_session`(...)
`configure_transaction`(→ None)
`rules_digest`(→ str)
`validate_context`(→ None)
`validate_lease`(→ None)
`lookup`(→ mainframe.models.scan_cache.CacheReply)
`renew_hits`(→ None)	Coalesce hot-key writes to hourly batches without reviving invalid entries.
`quarantine`(→ mainframe.models.scan_cache.CacheWriteReply)	Retain evidence and quota accounting; isolate only existing suspect keys.
`writer_lock`(→ bool)
`generation_for_write`(...)
`store`(→ mainframe.models.scan_cache.CacheWriteReply)
`expire_entries`(→ int)
`maintain_cache`(→ None)	Bound cleanup work per tick; idle caches remain physically bounded too.

Module Contents¶

mainframe.scan_cache.quarantined_entries[source]¶

mainframe.scan_cache.requests[source]¶

mainframe.scan_cache.latency[source]¶

mainframe.scan_cache.rows_written[source]¶

mainframe.scan_cache.rows_renewed[source]¶

mainframe.scan_cache.cache_size[source]¶

mainframe.scan_cache.cache_entries[source]¶

mainframe.scan_cache.cache_payload[source]¶

mainframe.scan_cache.rows_expired[source]¶

mainframe.scan_cache.admission_skips[source]¶

mainframe.scan_cache._gate[source]¶

mainframe.scan_cache._rate_lock[source]¶

mainframe.scan_cache._recent_requests: collections.deque[float][source]¶

mainframe.scan_cache.MAX_REQUESTS_PER_SECOND = 10[source]¶

mainframe.scan_cache.MAX_NAMESPACES = 8[source]¶

mainframe.scan_cache.CLEANUP_BATCH = 1000[source]¶

mainframe.scan_cache.cache_engine() → sqlalchemy.Engine[source]¶: Reserve at most one connection per API process, outside the queue pool.

mainframe.scan_cache.require_cache() → None[source]¶

mainframe.scan_cache.cache_session() → collections.abc.Generator[sqlalchemy.orm.Session, None, None][source]¶

mainframe.scan_cache.configure_transaction(session: sqlalchemy.orm.Session) → None[source]¶

mainframe.scan_cache.rules_digest(corpus: dict[str, str]) → str[source]¶

mainframe.scan_cache.validate_context(context: mainframe.models.scan_cache.CacheContext, rules: mainframe.rules.Rules) → None[source]¶

mainframe.scan_cache.validate_lease(session: sqlalchemy.orm.Session, scanner: str, lease: mainframe.models.scan_cache.CacheLease, subject: str) → None[source]¶

mainframe.scan_cache.lookup(session: sqlalchemy.orm.Session, request: mainframe.models.scan_cache.CacheLookup) → mainframe.models.scan_cache.CacheReply[source]¶

mainframe.scan_cache.renew_hits(session: sqlalchemy.orm.Session, context: mainframe.models.scan_cache.CacheContext, rows: list[mainframe.models.orm.ScanCacheEntry], now: datetime.datetime) → None[source]¶: Coalesce hot-key writes to hourly batches without reviving invalid entries.

mainframe.scan_cache.quarantine(session: sqlalchemy.orm.Session, context: mainframe.models.scan_cache.CacheContext, keys: list[mainframe.models.scan_cache.CacheKey]) → mainframe.models.scan_cache.CacheWriteReply[source]¶: Retain evidence and quota accounting; isolate only existing suspect keys.

mainframe.scan_cache.writer_lock(session: sqlalchemy.orm.Session, scanner: Literal['yara', 'opengrep']) → bool[source]¶

mainframe.scan_cache.generation_for_write(session: sqlalchemy.orm.Session, context: mainframe.models.scan_cache.CacheContext) → mainframe.models.orm.ScanCacheNamespace | None[source]¶

mainframe.scan_cache.store(session: sqlalchemy.orm.Session, context: mainframe.models.scan_cache.CacheContext, values: list[mainframe.models.scan_cache.CacheValue]) → mainframe.models.scan_cache.CacheWriteReply[source]¶

mainframe.scan_cache.expire_entries(session: sqlalchemy.orm.Session, scanner: Literal['yara', 'opengrep'], current_rules: str) → int[source]¶

mainframe.scan_cache.maintain_cache(current_rules: str) → None[source]¶: Bound cleanup work per tick; idle caches remain physically bounded too.