コード例 #1
0
ファイル: cmd.py プロジェクト: christophebedard/lttng-ust
 def __init__(self, header, loglevel, loglevel_type, name, filter_exp):
     super(self.__class__, self).__init__(header)
     self.loglevel = loglevel
     self.loglevel_type = loglevel_type
     self.name = name
     self.filter_expression = filter_exp
     dbg._pdebug('server enable command {}'.format(self.__dict__))
コード例 #2
0
    def _handle_server_cmd_list(self, server_cmd):
        dbg._pdebug(self._debug('got "list" server command'))
        names = logging.Logger.manager.loggerDict.keys()
        dbg._pdebug(self._debug('found {} loggers'.format(len(names))))
        cmd_reply = lttngust.cmd._ClientCmdReplyList(names=names)

        return cmd_reply
コード例 #3
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def _handle_server_cmd_list(self, server_cmd):
        dbg._pdebug(self._debug('got "list" server command'))
        names = logging.Logger.manager.loggerDict.keys()
        dbg._pdebug(self._debug("found {} loggers".format(len(names))))
        cmd_reply = lttngust.cmd._ClientCmdReplyList(names=names)

        return cmd_reply
コード例 #4
0
ファイル: cmd.py プロジェクト: MasonMoreland/lttng-ust
 def __init__(self, header, loglevel, loglevel_type, name, filter_exp):
     super(self.__class__, self).__init__(header)
     self.loglevel = loglevel
     self.loglevel_type = loglevel_type
     self.name = name
     self.filter_expression = filter_exp
     dbg._pdebug('server enable command {}'.format(self.__dict__))
コード例 #5
0
ファイル: cmd.py プロジェクト: christophebedard/lttng-ust
def _server_cmd_header_from_data(data):
    try:
        data_size, cmd_id, cmd_version = _server_cmd_header_struct.unpack(data)
    except (Exception) as e:
        dbg._pdebug('cannot decode command header: {}'.format(e))
        return None

    return _ServerCmdHeader(data_size, cmd_id, cmd_version)
コード例 #6
0
ファイル: cmd.py プロジェクト: christophebedard/lttng-ust
    def from_data(cls, header, data):
        try:
            name = data.rstrip(b'\0').decode()

            return cls(header, name)
        except (Exception) as e:
            dbg._pdebug('cannot decode disable command: {}'.format(e))
            return None
コード例 #7
0
ファイル: cmd.py プロジェクト: compudj/lttng-ust-dev
    def from_data(cls, header, data):
        try:
            name = data.rstrip(b'\0').decode()

            return cls(header, name)
        except (Exception) as e:
            dbg._pdebug('cannot decode disable command: {}'.format(e))
            return None
コード例 #8
0
ファイル: cmd.py プロジェクト: compudj/lttng-ust-dev
def _server_cmd_header_from_data(data):
    try:
        data_size, cmd_id, cmd_version = _server_cmd_header_struct.unpack(data)
    except (Exception) as e:
        dbg._pdebug('cannot decode command header: {}'.format(e))
        return None

    return _ServerCmdHeader(data_size, cmd_id, cmd_version)
コード例 #9
0
ファイル: cmd.py プロジェクト: compudj/lttng-ust-dev
    def from_data(cls, header, data):
        try:
            loglevel, loglevel_type = cls._loglevel_struct.unpack_from(data)
            data_name = data[cls._loglevel_struct.size:]
            name = data_name.rstrip(b'\0').decode()

            return cls(header, loglevel, loglevel_type, name)
        except (Exception) as e:
            dbg._pdebug('cannot decode enable command: {}'.format(e))
            return None
コード例 #10
0
ファイル: cmd.py プロジェクト: compudj/lttng-ust-dev
    def from_data(cls, header, data):
        try:
            loglevel, loglevel_type = cls._loglevel_struct.unpack_from(data)
            data_name = data[cls._loglevel_struct.size:]
            name = data_name.rstrip(b'\0').decode()

            return cls(header, loglevel, loglevel_type, name)
        except (Exception) as e:
            dbg._pdebug('cannot decode enable command: {}'.format(e))
            return None
コード例 #11
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def _recv_server_cmd_header(self):
        data = self._sessiond_sock.recv(lttngust.cmd._SERVER_CMD_HEADER_SIZE)

        if not data:
            dbg._pdebug(self._debug("received empty server command header"))
            return None

        assert len(data) == lttngust.cmd._SERVER_CMD_HEADER_SIZE
        dbg._pdebug(self._debug("received server command header ({} bytes)".format(len(data))))

        return lttngust.cmd._server_cmd_header_from_data(data)
コード例 #12
0
    def _recv_server_cmd_header(self):
        data = self._sessiond_sock.recv(lttngust.cmd._SERVER_CMD_HEADER_SIZE)

        if not data:
            dbg._pdebug(self._debug('received empty server command header'))
            return None

        assert (len(data) == lttngust.cmd._SERVER_CMD_HEADER_SIZE)
        dbg._pdebug(
            self._debug('received server command header ({} bytes)'.format(
                len(data))))

        return lttngust.cmd._server_cmd_header_from_data(data)
コード例 #13
0
    def _handle_server_cmd_reg_done(self, server_cmd):
        dbg._pdebug(self._debug('got "registration done" server command'))

        if self._reg_queue is not None:
            dbg._pdebug(self._debug('notifying _init_threads()'))

            try:
                self._reg_queue.put(True)
            except (Exception) as e:
                # read side could be closed by now; ignore it
                pass

            self._reg_queue = None
コード例 #14
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def _handle_server_cmd_reg_done(self, server_cmd):
        dbg._pdebug(self._debug('got "registration done" server command'))

        if self._reg_queue is not None:
            dbg._pdebug(self._debug("notifying _init_threads()"))

            try:
                self._reg_queue.put(True)
            except (Exception) as e:
                # read side could be closed by now; ignore it
                pass

            self._reg_queue = None
コード例 #15
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
def _get_port_from_file(path):
    port = None
    dbg._pdebug('reading port from file "{}"'.format(path))

    try:
        f = open(path)
        r_port = int(f.readline())
        f.close()

        if r_port > 0 or r_port <= 65535:
            port = r_port
    except:
        pass

    return port
コード例 #16
0
def _get_port_from_file(path):
    port = None
    dbg._pdebug('reading port from file "{}"'.format(path))

    try:
        f = open(path)
        r_port = int(f.readline())
        f.close()

        if r_port > 0 or r_port <= 65535:
            port = r_port
    except:
        pass

    return port
コード例 #17
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def _handle_server_cmd(self, server_cmd):
        cmd_reply = None

        if server_cmd is None:
            dbg._pdebug(self._debug("bad server command"))
            status = lttngust.cmd._CLIENT_CMD_REPLY_STATUS_INVALID_CMD
            cmd_reply = lttngust.cmd._ClientCmdReply(status)
        elif type(server_cmd) in self._server_cmd_handlers:
            cmd_reply = self._server_cmd_handlers[type(server_cmd)](server_cmd)
        else:
            dbg._pdebug(self._debug("unknown server command"))
            status = lttngust.cmd._CLIENT_CMD_REPLY_STATUS_INVALID_CMD
            cmd_reply = lttngust.cmd._ClientCmdReply(status)

        if cmd_reply is not None:
            self._send_cmd_reply(cmd_reply)
コード例 #18
0
    def _handle_server_cmd(self, server_cmd):
        cmd_reply = None

        if server_cmd is None:
            dbg._pdebug(self._debug('bad server command'))
            status = lttngust.cmd._CLIENT_CMD_REPLY_STATUS_INVALID_CMD
            cmd_reply = lttngust.cmd._ClientCmdReply(status)
        elif type(server_cmd) in self._server_cmd_handlers:
            cmd_reply = self._server_cmd_handlers[type(server_cmd)](server_cmd)
        else:
            dbg._pdebug(self._debug('unknown server command'))
            status = lttngust.cmd._CLIENT_CMD_REPLY_STATUS_INVALID_CMD
            cmd_reply = lttngust.cmd._ClientCmdReply(status)

        if cmd_reply is not None:
            self._send_cmd_reply(cmd_reply)
コード例 #19
0
ファイル: cmd.py プロジェクト: christophebedard/lttng-ust
    def from_data(cls, header, data):
        try:
            loglevel, loglevel_type = cls._loglevel_struct.unpack_from(data)
            name_start = cls._loglevel_struct.size
            name_end = name_start + _LTTNG_SYMBOL_NAME_LEN
            data_name = data[name_start:name_end]
            name = data_name.rstrip(b'\0').decode()

            filter_exp_start = name_end + cls._filter_exp_len_struct.size
            filter_exp_len, = cls._filter_exp_len_struct.unpack_from(
                data[name_end:filter_exp_start])
            filter_exp_end = filter_exp_start + filter_exp_len

            filter_exp = data[filter_exp_start:filter_exp_end].rstrip(
                b'\0').decode()

            return cls(header, loglevel, loglevel_type, name, filter_exp)
        except (Exception) as e:
            dbg._pdebug('cannot decode enable command: {}'.format(e))
            return None
コード例 #20
0
ファイル: cmd.py プロジェクト: MasonMoreland/lttng-ust
    def from_data(cls, header, data):
        try:
            loglevel, loglevel_type = cls._loglevel_struct.unpack_from(data)
            name_start = cls._loglevel_struct.size
            name_end = name_start + _LTTNG_SYMBOL_NAME_LEN
            data_name = data[name_start:name_end]
            name = data_name.rstrip(b'\0').decode()

            filter_exp_start = name_end + cls._filter_exp_len_struct.size
            filter_exp_len, = cls._filter_exp_len_struct.unpack_from(
                data[name_end:filter_exp_start])
            filter_exp_end = filter_exp_start + filter_exp_len

            filter_exp = data[filter_exp_start:filter_exp_end].rstrip(
                b'\0').decode()

            return cls(header, loglevel, loglevel_type, name, filter_exp)
        except (Exception) as e:
            dbg._pdebug('cannot decode enable command: {}'.format(e))
            return None
コード例 #21
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def _handle_server_cmd_enable(self, server_cmd):
        dbg._pdebug(self._debug('got "enable" server command'))
        self._ref_count += 1

        if self._ref_count == 1:
            dbg._pdebug(self._debug("adding our handler to the root logger"))
            self._root_logger.addHandler(self._log_handler)

        dbg._pdebug(self._debug("ref count is {}".format(self._ref_count)))

        return lttngust.cmd._ClientCmdReplyEnable()
コード例 #22
0
    def _handle_server_cmd_enable(self, server_cmd):
        dbg._pdebug(self._debug('got "enable" server command'))
        self._ref_count += 1

        if self._ref_count == 1:
            dbg._pdebug(self._debug('adding our handler to the root logger'))
            self._root_logger.addHandler(self._log_handler)

        dbg._pdebug(self._debug('ref count is {}'.format(self._ref_count)))

        return lttngust.cmd._ClientCmdReplyEnable()
コード例 #23
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def run(self):
        while True:
            try:
                # connect to the session daemon
                dbg._pdebug(self._debug("connecting to session daemon"))
                self._connect_to_sessiond()

                # register to the session daemon after a successful connection
                dbg._pdebug(self._debug("registering to session daemon"))
                self._register()

                # wait for commands from the session daemon
                self._wait_server_cmd()
            except (Exception) as e:
                # Whatever happens here, we have to close the socket and
                # retry to connect to the session daemon since either
                # the socket was closed, a network timeout occured, or
                # invalid data was received.
                dbg._pdebug(self._debug("got exception: {}".format(e)))
                self._cleanup_socket()
                dbg._pdebug(self._debug("sleeping for {} s".format(_RETRY_REG_DELAY)))
                time.sleep(_RETRY_REG_DELAY)
コード例 #24
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def _handle_server_cmd_disable(self, server_cmd):
        dbg._pdebug(self._debug('got "disable" server command'))
        self._ref_count -= 1

        if self._ref_count < 0:
            # disable command could be sent again when a session is destroyed
            self._ref_count = 0

        if self._ref_count == 0:
            dbg._pdebug(self._debug("removing our handler from the root logger"))
            self._root_logger.removeHandler(self._log_handler)

        dbg._pdebug(self._debug("ref count is {}".format(self._ref_count)))

        return lttngust.cmd._ClientCmdReplyDisable()
コード例 #25
0
    def _handle_server_cmd_disable(self, server_cmd):
        dbg._pdebug(self._debug('got "disable" server command'))
        self._ref_count -= 1

        if self._ref_count < 0:
            # disable command could be sent again when a session is destroyed
            self._ref_count = 0

        if self._ref_count == 0:
            dbg._pdebug(
                self._debug('removing our handler from the root logger'))
            self._root_logger.removeHandler(self._log_handler)

        dbg._pdebug(self._debug('ref count is {}'.format(self._ref_count)))

        return lttngust.cmd._ClientCmdReplyDisable()
コード例 #26
0
    def run(self):
        while True:
            try:
                # connect to the session daemon
                dbg._pdebug(self._debug('connecting to session daemon'))
                self._connect_to_sessiond()

                # register to the session daemon after a successful connection
                dbg._pdebug(self._debug('registering to session daemon'))
                self._register()

                # wait for commands from the session daemon
                self._wait_server_cmd()
            except (Exception) as e:
                # Whatever happens here, we have to close the socket and
                # retry to connect to the session daemon since either
                # the socket was closed, a network timeout occured, or
                # invalid data was received.
                dbg._pdebug(self._debug('got exception: {}'.format(e)))
                self._cleanup_socket()
                dbg._pdebug(
                    self._debug('sleeping for {} s'.format(_RETRY_REG_DELAY)))
                time.sleep(_RETRY_REG_DELAY)
コード例 #27
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
    def _recv_server_cmd(self):
        server_cmd_header = self._recv_server_cmd_header()

        if server_cmd_header is None:
            return None

        dbg._pdebug(self._debug("server command header: data size: {} bytes".format(server_cmd_header.data_size)))
        dbg._pdebug(self._debug("server command header: command ID: {}".format(server_cmd_header.cmd_id)))
        dbg._pdebug(self._debug("server command header: command version: {}".format(server_cmd_header.cmd_version)))
        data = bytes()

        if server_cmd_header.data_size > 0:
            data = self._sessiond_sock.recv(server_cmd_header.data_size)
            assert len(data) == server_cmd_header.data_size

        return lttngust.cmd._server_cmd_from_data(server_cmd_header, data)
コード例 #28
0
    def _recv_server_cmd(self):
        server_cmd_header = self._recv_server_cmd_header()

        if server_cmd_header is None:
            return None

        dbg._pdebug(
            self._debug('server command header: data size: {} bytes'.format(
                server_cmd_header.data_size)))
        dbg._pdebug(
            self._debug('server command header: command ID: {}'.format(
                server_cmd_header.cmd_id)))
        dbg._pdebug(
            self._debug('server command header: command version: {}'.format(
                server_cmd_header.cmd_version)))
        data = bytes()

        if server_cmd_header.data_size > 0:
            data = self._sessiond_sock.recv(server_cmd_header.data_size)
            assert (len(data) == server_cmd_header.data_size)

        return lttngust.cmd._server_cmd_from_data(server_cmd_header, data)
コード例 #29
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
def _init_threads():
    global _initialized

    dbg._pdebug("entering")

    if _initialized:
        dbg._pdebug("agent is already initialized")
        return

    # This makes sure that the appropriate modules for encoding and
    # decoding strings/bytes are imported now, since no import should
    # happen within a thread at import time (our case).
    "lttng".encode().decode()

    _initialized = True
    sys_port = _get_port_from_file("/var/run/lttng/agent.port")
    user_port_file = os.path.join(_get_user_home_path(), ".lttng", "agent.port")
    user_port = _get_port_from_file(user_port_file)
    reg_queue = queue.Queue()
    reg_expecting = 0

    dbg._pdebug("system session daemon port: {}".format(sys_port))
    dbg._pdebug("user session daemon port: {}".format(user_port))

    if sys_port == user_port and sys_port is not None:
        # The two session daemon ports are the same. This is not normal.
        # Connect to only one.
        dbg._pdebug("both user and system session daemon have the same port")
        sys_port = None

    try:
        if sys_port is not None:
            dbg._pdebug("creating system client thread")
            t = threading.Thread(target=_client_thread_target, args=("system", sys_port, reg_queue))
            t.name = "system"
            t.daemon = True
            t.start()
            dbg._pdebug("created and started system client thread")
            reg_expecting += 1

        if user_port is not None:
            dbg._pdebug("creating user client thread")
            t = threading.Thread(target=_client_thread_target, args=("user", user_port, reg_queue))
            t.name = "user"
            t.daemon = True
            t.start()
            dbg._pdebug("created and started user client thread")
            reg_expecting += 1
    except:
        # cannot create threads for some reason; stop this initialization
        dbg._pwarning("cannot create client threads")
        return

    if reg_expecting == 0:
        # early exit: looks like there's not even one valid port
        dbg._pwarning("no valid LTTng session daemon port found (is the session daemon started?)")
        return

    cur_timeout = _REG_TIMEOUT

    # We block here to make sure the agent is properly registered to
    # the session daemon. If we timeout, the client threads will still
    # continue to try to connect and register to the session daemon,
    # but there is no guarantee that all following logging statements
    # will make it to LTTng-UST.
    #
    # When a client thread receives a "registration done" confirmation
    # from the session daemon it's connected to, it puts True in
    # reg_queue.
    while True:
        try:
            dbg._pdebug(
                "waiting for registration done (expecting {}, timeout is {} s)".format(reg_expecting, cur_timeout)
            )
            t1 = time.clock()
            reg_queue.get(timeout=cur_timeout)
            t2 = time.clock()
            reg_expecting -= 1
            dbg._pdebug("unblocked")

            if reg_expecting == 0:
                # done!
                dbg._pdebug("successfully registered to session daemon(s)")
                break

            cur_timeout -= t2 - t1

            if cur_timeout <= 0:
                # timeout
                dbg._pdebug("ran out of time")
                break
        except queue.Empty:
            dbg._pdebug("ran out of time")
            break

    dbg._pdebug("leaving")
コード例 #30
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
 def _send_cmd_reply(self, cmd_reply):
     data = cmd_reply.get_data()
     dbg._pdebug(self._debug("sending command reply ({} bytes)".format(len(data))))
     self._sessiond_sock.sendall(data)
コード例 #31
0
ファイル: agent.py プロジェクト: ramarag/lttng-ust
def _client_thread_target(name, port, reg_queue):
    dbg._pdebug('creating client "{}" using TCP port {}'.format(name, port))
    client = _TcpClient(name, _SESSIOND_HOST, port, reg_queue)
    dbg._pdebug('starting client "{}"'.format(name))
    client.run()
コード例 #32
0
 def _send_cmd_reply(self, cmd_reply):
     data = cmd_reply.get_data()
     dbg._pdebug(
         self._debug('sending command reply ({} bytes)'.format(len(data))))
     self._sessiond_sock.sendall(data)
コード例 #33
0
def _init_threads():
    global _initialized

    dbg._pdebug('entering')

    if _initialized:
        dbg._pdebug('agent is already initialized')
        return

    # This makes sure that the appropriate modules for encoding and
    # decoding strings/bytes are imported now, since no import should
    # happen within a thread at import time (our case).
    'lttng'.encode().decode()

    _initialized = True
    sys_port = _get_port_from_file('/var/run/lttng/agent.port')
    user_port_file = os.path.join(_get_user_home_path(), '.lttng',
                                  'agent.port')
    user_port = _get_port_from_file(user_port_file)
    reg_queue = queue.Queue()
    reg_expecting = 0

    dbg._pdebug('system session daemon port: {}'.format(sys_port))
    dbg._pdebug('user session daemon port: {}'.format(user_port))

    if sys_port == user_port and sys_port is not None:
        # The two session daemon ports are the same. This is not normal.
        # Connect to only one.
        dbg._pdebug('both user and system session daemon have the same port')
        sys_port = None

    try:
        if sys_port is not None:
            dbg._pdebug('creating system client thread')
            t = threading.Thread(target=_client_thread_target,
                                 args=('system', sys_port, reg_queue))
            t.name = 'system'
            t.daemon = True
            t.start()
            dbg._pdebug('created and started system client thread')
            reg_expecting += 1

        if user_port is not None:
            dbg._pdebug('creating user client thread')
            t = threading.Thread(target=_client_thread_target,
                                 args=('user', user_port, reg_queue))
            t.name = 'user'
            t.daemon = True
            t.start()
            dbg._pdebug('created and started user client thread')
            reg_expecting += 1
    except:
        # cannot create threads for some reason; stop this initialization
        dbg._pwarning('cannot create client threads')
        return

    if reg_expecting == 0:
        # early exit: looks like there's not even one valid port
        dbg._pwarning(
            'no valid LTTng session daemon port found (is the session daemon started?)'
        )
        return

    cur_timeout = _REG_TIMEOUT

    # We block here to make sure the agent is properly registered to
    # the session daemon. If we timeout, the client threads will still
    # continue to try to connect and register to the session daemon,
    # but there is no guarantee that all following logging statements
    # will make it to LTTng-UST.
    #
    # When a client thread receives a "registration done" confirmation
    # from the session daemon it's connected to, it puts True in
    # reg_queue.
    while True:
        try:
            dbg._pdebug(
                'waiting for registration done (expecting {}, timeout is {} s)'
                .format(reg_expecting, cur_timeout))
            t1 = lttngust.compat._clock()
            reg_queue.get(timeout=cur_timeout)
            t2 = lttngust.compat._clock()
            reg_expecting -= 1
            dbg._pdebug('unblocked')

            if reg_expecting == 0:
                # done!
                dbg._pdebug('successfully registered to session daemon(s)')
                break

            cur_timeout -= (t2 - t1)

            if cur_timeout <= 0:
                # timeout
                dbg._pdebug('ran out of time')
                break
        except queue.Empty:
            dbg._pdebug('ran out of time')
            break

    dbg._pdebug('leaving')
コード例 #34
0
def _client_thread_target(name, port, reg_queue):
    dbg._pdebug('creating client "{}" using TCP port {}'.format(name, port))
    client = _TcpClient(name, _SESSIOND_HOST, port, reg_queue)
    dbg._pdebug('starting client "{}"'.format(name))
    client.run()