%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /opt/imunify360/venv/lib64/python3.8/site-packages/defence360agent/plugins/
Upload File :
Create Path :
Current File : //opt/imunify360/venv/lib64/python3.8/site-packages/defence360agent/plugins/accumulate.py

"""
This program is free software: you can redistribute it and/or modify it under 
the terms of the GNU General Public License as published by 
the Free Software Foundation, either version 3 of the License, 
or (at your option) any later version.


This program is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
See the GNU General Public License for more details.


You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.

Copyright © 2019 Cloud Linux Software Inc.

This software is also available under ImunifyAV commercial license,
see <https://www.imunify360.com/legal/eula>
"""
import asyncio
import collections
import contextlib
import os
from logging import getLogger

from defence360agent.contracts.messages import MessageType
from defence360agent.contracts.plugins import (MessageSink, MessageSource,
                                               expect)
from defence360agent.utils import recurring_check

logger = getLogger(__name__)


class Accumulate(MessageSink, MessageSource):
    PROCESSING_ORDER = MessageSink.ProcessingOrder.POST_PROCESS_MESSAGE
    DEFAULT_AGGREGATE_TIMEOUT = int(
        os.environ.get("IMUNIFY360_AGGREGATE_MESSAGES_TIMEOUT", 60)
    )

    def __init__(self, period=DEFAULT_AGGREGATE_TIMEOUT, **kwargs):
        super().__init__(**kwargs)
        self._period = period

    async def create_source(self, loop, sink):
        self._loop = loop
        self._sink = sink
        self._task = loop.create_task(
            recurring_check(self._period)(self._flush)())
        self._data = collections.defaultdict(list)

    async def create_sink(self, loop):
        self._loop = loop

    async def shutdown(self):
        if self._task is not None:
            self._task.cancel()
            with contextlib.suppress(asyncio.CancelledError):
                await self._task

    @expect(MessageType.Accumulatable)
    async def collect(self, message):
        list_type = message.LIST_CLASS
        if message.do_accumulate():
            self._data[list_type].append(message)

    async def _flush(self):
        copy_data = self._data
        self._data = collections.defaultdict(list)

        for list_type, messages in copy_data.items():
            try:
                # FIXME: remove this try..except block after we have forbidden
                #  to create Accumulatable class without LIST_CLASS.
                await self._sink.process_message(list_type(items=messages))
            except TypeError:
                logger.error("%s, %s", list_type, messages)
                raise

Zerion Mini Shell 1.0