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']