def __init__(self, manager_handler, filename, worker_name, stopper):
"""
Abstract class which defines the necessary methods to receive a file
"""
ClusterThread.__init__(self, stopper)
self.manager_handler = manager_handler # handler object
self.filename = filename # filename of the file to receive
self.name = worker_name # name of the sender
self.command_queue = Queue() # queue to store received file commands
self.received_all_information = False # flag to indicate whether all file has been received
self.received_error = False # flag to indicate there has been an error in receiving process
self.f = None # file object that is being received
self.id = None # id of the thread doing the receiving process
self.thread_tag = "[FileThread]" # logger tag of the thread
self.n_get_timeouts = 0 # number of times Empty exception is raised
self.start_time = 0 # debug: start receiving time
self.end_time = 0 # debug: end time
self.total_time = 0 # debug: total time receiving
self.size_received = 0 # debug: total bytes received
#Intervals
self.interval_file_transfer_receive = get_cluster_items_communication_intervals(
)['file_transfer_receive']
self.max_time_receiving_file = get_cluster_items_communication_intervals(
)['max_time_receiving_file']
def __init__(self, manager_handler, stopper):
"""
Abstract class which defines the necessary methods to receive a fragmented string request
"""
FragmentedRequestReceiver.__init__(self, manager_handler, stopper)
self.sting_received = b""
#Debug
self.thread_tag = "[StringThread]" # logger tag of the thread
#Intervals
self.interval_transfer_receive = get_cluster_items_communication_intervals(
)['string_transfer_receive']
self.max_time_receiving = get_cluster_items_communication_intervals(
)['max_time_receiving_string']
def __init__(self, manager_handler, filename, worker_name, stopper):
"""
Abstract class which defines the necessary methods to receive and process a fragmented file
"""
FragmentedRequestReceiver.__init__(self, manager_handler, stopper)
self.filename = filename # filename of the file to receive
self.name = worker_name # name of the sender
self.f = None # file object that is being received
#Debug
self.thread_tag = "[FileThread]" # logger tag of the thread
#Intervals
self.interval_transfer_receive = get_cluster_items_communication_intervals(
)['file_transfer_receive']
self.max_time_receiving = get_cluster_items_communication_intervals(
)['max_time_receiving_file']
def __init__(self, key, host, port, name, cluster_name, asyncore_map={}):
connect_query = '{}*{} {} {}'.format(name, cluster_name, 'worker',
__version__)
AbstractClient.__init__(self, key, (host, port), name, socket.AF_INET,
socket.SOCK_STREAM, connect_query, "[Worker ]",
asyncore_map)
self.host = host
self.cluster_name = cluster_name
self.port = port
self.interval_string_transfer_send = get_cluster_items_communication_intervals(
)['string_transfer_send']
def __init__(self,
addr,
handle_type,
socket_type,
socket_family,
tag,
asyncore_map={}):
asyncore.dispatcher.__init__(self, map=asyncore_map)
self.handle_type = handle_type
self.map = asyncore_map
self._workers = {}
self.tag = tag
self._workers_lock = threading.Lock()
self.create_socket(socket_family, socket_type)
self.set_reuse_addr()
self.bind(addr)
self.listen(128) # number of pending connections the queue will hold
self.interval_file_transfer_send = get_cluster_items_communication_intervals(
)['file_transfer_send']
self.interval_string_transfer_send = get_cluster_items_communication_intervals(
)['string_transfer_send']
def __init__(self, host, port, handle_type, asyncore_map = {}):
asyncore.dispatcher.__init__(self, map=asyncore_map)
self._clients = {}
self._clients_lock = threading.Lock()
self.map = asyncore_map
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((host, port))
self.listen(5)
self.handle_type = handle_type
self.interval_file_transfer_send = get_cluster_items_communication_intervals()['file_transfer_send']
def execute(request, disable_timeout=False):
socket_name = "c-internal"
try:
# if no exception is raised from function check_cluster_status, the cluster is ok.
check_cluster_status()
# This event will be set when the final response is received
data_received = threading.Event()
# Create socket client
isocket_worker_thread = InternalSocketWorkerThread(
socket_name=socket_name, data_received=data_received)
isocket_worker_thread.start()
# Send request
command, payload = request.split(' ', 1)
raw_response = isocket_worker_thread.manager.send_request(
command=command, data=payload).split(' ', 1)
isocket_worker_thread.manager.process_response(raw_response)
# Wait response
# Data received will be free when dapi_forward request is received, or when a json/err response is processed.
logger.debug("Waiting response.")
timeout_not_expired = data_received.wait(
None if disable_timeout else
get_cluster_items_communication_intervals()['timeout_api_request'])
if timeout_not_expired:
response = json.loads(isocket_worker_thread.manager.final_data)
else:
response = {
"error": 1000,
"message": "Timeout waiting local server."
}
# Stop socket client
isocket_worker_thread.stop()
return response
except WazuhException as e:
raise e
except Exception as e:
raise WazuhException(3009, str(e))
def __init__(self):
self.cond = threading.Condition()
self.data = None
self.response_timeout = get_cluster_items_communication_intervals(
)['timeout_cluster_request']
