def __init__(self, server):
self.request_queue = asyncio.Queue()
self.server = server
self.logger = logging.getLogger('wazuh').getChild('dapi')
self.logger.addFilter(
cluster.ClusterFilter(tag='Cluster', subtag='D API'))
self.pending_requests = {}
def __init__(self,
performance_test: int,
concurrency_test: int,
configuration: Dict,
cluster_items: Dict,
enable_ssl: bool,
logger: logging.Logger,
tag: str = "Abstract Server"):
"""
Class constructor
:param performance_test: Message length to use in the performance test
:param concurrency_test: Number of requests to do in the concurrency test
:param configuration: ossec.conf cluster configuration
:param cluster_items: cluster.json cluster internal configuration
:param enable_ssl: Whether to enable asyncio's SSL support
:param logger: Logger to use
:param tag: Log tag
"""
self.clients = {}
self.performance = performance_test
self.concurrency = concurrency_test
self.configuration = configuration
self.cluster_items = cluster_items
self.enable_ssl = enable_ssl
self.tag = tag
self.logger = logger.getChild(tag)
# logging tag
self.logger.addFilter(cluster.ClusterFilter(tag=tag, subtag="Main"))
self.tasks = [self.check_clients_keepalive]
self.handler_class = AbstractServerHandler
self.loop = asyncio.get_running_loop()
def __init__(self, configuration: Dict, cluster_items: Dict, enable_ssl: bool, performance_test: int,
concurrency_test: int, file: str, string: int, logger: logging.Logger, tag: str = "Client Manager"):
"""
Class constructor
:param configuration: client configuration
:param enable_ssl: Whether to use SSL encryption or not
:param performance_test: Value for the performance test function
:param concurrency_test: Value for the concurrency test function
:param file: File path for the send file test function
:param string: String size for the send string test function
"""
self.name = configuration['node_name']
self.configuration = configuration
self.cluster_items = cluster_items
self.ssl = enable_ssl
self.performance_test = performance_test
self.concurrency_test = concurrency_test
self.file = file
self.string = string
self.logger = logger.getChild(tag)
# logging tag
self.tag = tag
self.logger.addFilter(cluster.ClusterFilter(tag=self.tag, subtag="Main"))
self.tasks = []
self.handler_class = AbstractClient
self.client = None
self.extra_args = {}
self.loop = asyncio.get_running_loop()
def __init__(self,
fernet_key: str,
logger: logging.Logger,
cluster_items: Dict,
tag: str = "Handler"):
"""
Class constructor
:param fernet_key: 32 length string used as key to initialize cryptography's Fernet.
:param tag: logging tag to use
"""
super().__init__()
# The counter is used to identify each message. If an incoming request has a known ID,
# it is processed as a response
self.counter = random.SystemRandom().randint(0, 2**32 - 1)
# The box stores all sent messages IDs
self.box = {}
# defines command length
self.cmd_len = 12
# defines header length
self.header_len = self.cmd_len + 8 # 4 bytes of counter and 4 bytes of message size
# defines header format
self.header_format = '!2I{}s'.format(self.cmd_len)
# stores received data
self.in_buffer = b''
# stores last received message
self.in_msg = InBuffer()
# stores incoming file information from file commands
self.in_file = {}
# stores incoming string information from string commands
self.in_str = {}
# maximum message length to send in a single request
self.request_chunk = 5242880
# stores message to be sent
self.out_msg = bytearray(self.header_len + self.request_chunk * 2)
# object use to encrypt and decrypt requests
self.my_fernet = cryptography.fernet.Fernet(
base64.b64encode(fernet_key.encode())) if fernet_key else None
# logging.Logger object used to write logs
self.logger = logger.getChild(tag)
# logging tag
self.tag = tag
self.logger_filter = cluster.ClusterFilter(tag=self.tag, subtag="Main")
self.logger.addFilter(self.logger_filter)
self.cluster_items = cluster_items
# transports in asyncio are an abstraction of sockets
self.transport = None
def set_logging(debug_mode=0):
logger = logging.getLogger('wazuh')
logger.propagate = False
# configure logger
fh = cluster.CustomFileRotatingHandler(
filename="{}/logs/cluster.log".format(common.ossec_path),
when='midnight')
formatter = logging.Formatter(
fmt=
'%(asctime)s wazuh-clusterd: %(levelname)s: [%(tag)s] [%(subtag)s] %(message)s',
datefmt="%Y/%m/%d %H:%M:%S")
formatter.converter = time.gmtime
fh.setFormatter(formatter)
logger.addHandler(fh)
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.addFilter(cluster.ClusterFilter(tag='Cluster', subtag='Main'))
# add a new debug level
logging.DEBUG2 = 5
def debug2(self, message, *args, **kws):
if self.isEnabledFor(logging.DEBUG2):
self._log(logging.DEBUG2, message, args, **kws)
def error(self, msg, *args, **kws):
if self.isEnabledFor(logging.ERROR):
kws['exc_info'] = self.isEnabledFor(logging.DEBUG2)
self._log(logging.ERROR, msg, args, **kws)
logging.addLevelName(logging.DEBUG2, "DEBUG2")
logging.Logger.debug2 = debug2
logging.Logger.error = error
debug_level = logging.DEBUG2 if debug_mode == 2 else logging.DEBUG if \
debug_mode == 1 else logging.INFO
logger.setLevel(debug_level)
return logger
def __init__(self,
performance_test: int,
concurrency_test: int,
configuration: Dict,
cluster_items: Dict,
enable_ssl: bool,
logger: logging.Logger,
tag: str = "Abstract Server"):
self.clients = {}
self.performance = performance_test
self.concurrency = concurrency_test
self.configuration = configuration
self.cluster_items = cluster_items
self.enable_ssl = enable_ssl
self.tag = tag
self.logger = logger.getChild(tag)
# logging tag
self.logger.addFilter(cluster.ClusterFilter(tag=tag, subtag="Main"))
self.tasks = [self.check_clients_keepalive]
self.handler_class = AbstractServerHandler
self.loop = asyncio.get_running_loop()
def setup_task_logger(self, task_tag: str):
task_logger = self.logger.getChild(task_tag)
task_logger.addFilter(
cluster.ClusterFilter(tag=self.tag, subtag=task_tag))
return task_logger
