Supported analyzer types. """ import os import re from codechecker_analyzer import env from codechecker_common.logger import get_logger from .. import host_check from .clangtidy.analyzer import ClangTidy from .clangsa.analyzer import ClangSA LOG = get_logger('analyzer') supported_analyzers = {ClangSA.ANALYZER_NAME: ClangSA, ClangTidy.ANALYZER_NAME: ClangTidy} def is_ctu_capable(context): """ Detects if the current clang is CTU compatible. """ enabled_analyzers, _ = \ check_supported_analyzers([ClangSA.ANALYZER_NAME], context) if not enabled_analyzers: return False clangsa_cfg = ClangSA.construct_config_handler([], context) return clangsa_cfg.ctu_capability.is_ctu_capable
from __future__ import division from __future__ import absolute_import import getpass import json import os import psutil import socket import stat import portalocker from codechecker_common.logger import get_logger from codechecker_common.util import load_json_or_empty LOG = get_logger('system') def __get_instance_descriptor_path(folder=None): if not folder: folder = os.path.expanduser("~") return os.path.join(folder, ".codechecker.instances.json") def __make_instance_descriptor_file(folder=None): descriptor = __get_instance_descriptor_path(folder) if not os.path.exists(descriptor): with open(descriptor, 'w') as f: json.dump([], f) os.chmod(descriptor, stat.S_IRUSR | stat.S_IWUSR)
# ------------------------------------------------------------------------- """ Result handler for Clang Tidy. """ from __future__ import print_function from __future__ import division from __future__ import absolute_import from codechecker_common import report from codechecker_common.logger import get_logger from ..result_handler_base import ResultHandler from . import output_converter LOG = get_logger('report') def generate_plist_from_tidy_result(output_file, tidy_stdout): """ Generate a plist file from the clang tidy analyzer results. """ parser = output_converter.OutputParser() messages = parser.parse_messages(tidy_stdout) plist_converter = output_converter.PListConverter() plist_converter.add_messages(messages) plist_converter.write_to_file(output_file)
""" Helpers to profile. """ from datetime import datetime import cProfile import pstats from functools import wraps from io import StringIO from codechecker_common import logger from codechecker_common.logger import get_logger LOG = get_logger('profiler') class Timer(object): """ Simple timer context manager to measure code block execution time. """ def __init__(self, block_name=''): self.block_name = block_name def __enter__(self): self.before = datetime.now() def __exit__(self, timer_type, value, traceback): after = datetime.now()
from datetime import datetime import cProfile import pstats from functools import wraps try: from StringIO import StringIO except ImportError: from io import BytesIO as StringIO from codechecker_common import logger from codechecker_common.logger import get_logger LOG = get_logger('profiler') class Timer(object): """ Simple timer context manager to measure code block execution time. """ def __init__(self, block_name=''): self.block_name = block_name def __enter__(self): self.before = datetime.now() def __exit__(self, timer_type, value, traceback): after = datetime.now()
def init_logger(level, logger_name='system'): logger.setup_logger(level) global LOG LOG = logger.get_logger(logger_name)
def init_logger(level, stream=None, logger_name='system'): logger.setup_logger(level, stream) global LOG LOG = logger.get_logger(logger_name)
for the plist_parser module. """ from __future__ import print_function from __future__ import division from __future__ import absolute_import import copy import json import os import plistlib import re from codechecker_common.logger import get_logger from codechecker_common.report import generate_report_hash LOG = get_logger('analyzer.tidy') class Note(object): """ Represents a note and also this is the base class of Message. """ def __init__(self, path, line, column, message): self.path = path self.line = line self.column = column self.message = message def __eq__(self, other): return self.path == other.path and \
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """ Config handler for Clang Tidy analyzer. """ from codechecker_common.logger import get_logger from .. import config_handler LOG = get_logger('analyzer.tidy') class ClangTidyConfigHandler(config_handler.AnalyzerConfigHandler): """ Configuration handler for Clang-tidy analyzer. """ def __init__(self): super(ClangTidyConfigHandler, self).__init__() def set_checker_enabled(self, checker_name, enabled=True): """ Enable checker, keep description if already set. """ if checker_name.startswith('W') or \ checker_name.startswith('clang-diagnostic-'):
# LLVM Exceptions. See LICENSE for license information. # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # # ------------------------------------------------------------------------- """ Clang Static analyzer configuration handler. """ import os from codechecker_analyzer import env from codechecker_common.logger import get_logger from .ctu_autodetection import CTUAutodetection from .. import config_handler LOG = get_logger('analyzer.clangsa') class ClangSAConfigHandler(config_handler.AnalyzerConfigHandler): """ Configuration handler for the clang static analyzer. """ def __init__(self, environ): super(ClangSAConfigHandler, self).__init__() self.ctu_dir = '' self.ctu_on_demand = False self.log_file = '' self.path_env_extra = '' self.ld_lib_path_extra = '' self.enable_z3 = False
from .database.config_db_model import Session as SessionRecord from .database.config_db_model import SystemPermission UNSUPPORTED_METHODS = [] try: from .auth import cc_ldap except ImportError: UNSUPPORTED_METHODS.append('ldap') try: from .auth import cc_pam except ImportError: UNSUPPORTED_METHODS.append('pam') LOG = get_logger("server") SESSION_COOKIE_NAME = _SCN def generate_session_token(): """ Returns a random session token. """ return uuid.UUID(bytes=os.urandom(16)).hex def get_worker_processes(scfg_dict, default=10): """ Return number of worker processes from the config dictionary. Return 'worker_processes' field from the config dictionary or returns the
# ------------------------------------------------------------------------- """ Clang Static analyzer configuration handler. """ from __future__ import print_function from __future__ import division from __future__ import absolute_import import re from codechecker_common.logger import get_logger from .. import config_handler LOG = get_logger('analyzer.clangsa') class ClangSAConfigHandler(config_handler.AnalyzerConfigHandler): """ Configuration handler for the clang static analyzer. """ def __init__(self): super(ClangSAConfigHandler, self).__init__() self.__checker_configs = [] self.ctu_dir = '' self.log_file = '' self.path_env_extra = '' self.ld_lib_path_extra = ''
from .database.config_db_model import SystemPermission UNSUPPORTED_METHODS = [] try: from .auth import cc_ldap except ImportError: UNSUPPORTED_METHODS.append('ldap') try: from .auth import cc_pam except ImportError: UNSUPPORTED_METHODS.append('pam') LOG = get_logger("server") SESSION_COOKIE_NAME = _SCN class _Session(object): """A session for an authenticated, privileged client connection.""" def __init__(self, token, username, groups, session_lifetime, refresh_time, is_root=False, database=None, last_access=None, can_expire=True): self.token = token self.user = username self.groups = groups self.session_lifetime = session_lifetime
from codechecker_server import instance_manager, server from codechecker_server.database import database from codechecker_server.database.config_db_model \ import IDENTIFIER as CONFIG_META from codechecker_server.database.config_db_model \ import Product as ORMProduct from codechecker_server.database.run_db_model \ import IDENTIFIER as RUN_META from codechecker_server.env import is_localhost from codechecker_web.shared import webserver_context, database_status, \ host_check from codechecker_web.shared.env import get_default_workspace, get_user_input LOG = logger.get_logger('server') def get_argparser_ctor_args(): """ This method returns a dict containing the kwargs for constructing an argparse.ArgumentParser (either directly or as a subparser). """ return { 'prog': 'CodeChecker server', 'formatter_class': argparse.ArgumentDefaultsHelpFormatter, # Description is shown when the command's help is queried directly
from __future__ import division from __future__ import absolute_import import os import pickle import platform import subprocess import sys from uuid import uuid4 from codechecker_common.logger import get_logger from .. import analyzer_env from . import host_check LOG = get_logger('buildlogger') def execute_buildcmd(command, silent=False, env=None, cwd=None): """ Execute the the build command and continuously write the output from the process to the standard output. """ proc = subprocess.Popen(command, bufsize=-1, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=cwd, shell=True)
import re import shlex import subprocess import sys import tempfile import traceback from codechecker_analyzer.analyzers import clangsa from codechecker_common.logger import get_logger from codechecker_common.util import load_json_or_empty from .. import gcc_toolchain from .build_action import BuildAction LOG = get_logger('buildlogger') SOURCE_EXTENSIONS = { ".c", ".cc", ".cp", ".cpp", ".cxx", ".c++", ".o", ".so", ".a" } # Replace gcc/g++ build target options with values accepted by Clang. REPLACE_OPTIONS_MAP = { '-mips32': ['-target', 'mips', '-mips32'], '-mips64': ['-target', 'mips64', '-mips64'], '-mpowerpc': ['-target', 'powerpc'], '-mpowerpc64': ['-target', 'powerpc64'] } # The compilation flags of which the prefix is any of these regular expressions # will not be included in the output Clang command.
""" from __future__ import print_function from __future__ import division from __future__ import absolute_import import glob import os import shutil import tempfile from codechecker_common.logger import get_logger from .. import analyzer_base from . import ctu_triple_arch LOG = get_logger('analyzer') def generate_func_map_lines(fnmap_dir): """ Iterate over all lines of input files in random order. """ files = glob.glob(os.path.join(fnmap_dir, '*')) for filename in files: with open(filename, 'r') as in_file: for line in in_file: yield line def create_global_ctu_function_map(func_map_lines): """ Takes iterator of individual function maps and creates a global map keeping only unique names. We leave conflicting names out of CTU.
# The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """ Parsers for the analyzer output formats (plist ...) should create this Report which will be stored. """ import json from codechecker_common.logger import get_logger from codechecker_common import util LOG = get_logger('report') class Report(object): """ Just a minimal separation of the main section from the path section for easier skip/suppression handling and result processing. """ def __init__(self, main, bugpath, files): # Dictionary containing checker name, report hash, # main report position, report message ... self.__main = main # Dictionary containing bug path related data # with control, event ... sections.
import json import shared from Authentication_v6.ttypes import * from codechecker_common.logger import get_logger from codechecker_common.profiler import timeit from codechecker_common.util import generate_session_token, DBSession from ..database.config_db_model import Session from ..permissions import handler_from_scope_params as make_handler from ..permissions import require_manager, require_permission from ..server import permissions LOG = get_logger('server') class ThriftAuthHandler(object): """ Handle Thrift authentication requests. """ def __init__(self, manager, auth_session, config_database): self.__manager = manager self.__auth_session = auth_session self.__config_db = config_database def __require_privilaged_access(self): """ Checks if privilaged access is enabled for the server. Throws an
stdout. """ import argparse import os import shutil import tempfile from codechecker_analyzer import analyzer_context from codechecker_analyzer.analyzers import analyzer_types from codechecker_analyzer.arg import OrderedCheckersAction from codechecker_common import arg, logger from codechecker_common.source_code_comment_handler import REVIEW_STATUS_VALUES LOG = logger.get_logger('system') def get_argparser_ctor_args(): """ This method returns a dict containing the kwargs for constructing an argparse.ArgumentParser (either directly or as a subparser). """ return { 'prog': 'CodeChecker check', 'formatter_class': arg.RawDescriptionDefaultHelpFormatter, # Description is shown when the command's help is queried directly
from shared.ttypes import Permission, RequestFailed, ErrorCode from codechecker_client import client as libclient from codechecker_common import logger from codechecker_common import util from codechecker_common import plist_parser from codechecker_common.output_formatters import twodim_to_str from codechecker_common.source_code_comment_handler import \ SourceCodeCommentHandler from codechecker_common.util import sizeof_fmt from codechecker_common.util import split_product_url from codechecker_web.shared import webserver_context, host_check LOG = logger.get_logger('system') MAX_UPLOAD_SIZE = 1 * 1024 * 1024 * 1024 # 1GiB def get_argparser_ctor_args(): """ This method returns a dict containing the kwargs for constructing an argparse.ArgumentParser (either directly or as a subparser). """ return { 'prog': 'CodeChecker store', 'formatter_class': argparse.ArgumentDefaultsHelpFormatter, # Description is shown when the command's help is queried directly
from .tmp import get_tmp_dir_hash from .api.authentication import ThriftAuthHandler as AuthHandler_v6 from .api.config_handler import ThriftConfigHandler as ConfigHandler_v6 from .api.product_server import ThriftProductHandler as ProductHandler_v6 from .api.report_server import ThriftRequestHandler as ReportHandler_v6 from .api.server_info_handler import \ ThriftServerInfoHandler as ServerInfoHandler_v6 from .database import database, db_cleanup from .database.config_db_model import Product as ORMProduct, \ Configuration as ORMConfiguration from .database.database import DBSession from .database.run_db_model import IDENTIFIER as RUN_META, Run, RunLock LOG = get_logger('server') class RequestHandler(SimpleHTTPRequestHandler): """ Handle thrift and browser requests Simply modified and extended version of SimpleHTTPRequestHandler """ auth_session = None def __init__(self, request, client_address, server): BaseHTTPRequestHandler.__init__(self, request, client_address, server) def log_message(self, msg_format, *args): """ Silencing http server. """ return
# License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """ Functions to check the host machine and the analyzers for various features, dependecies and configurations. """ from __future__ import print_function from __future__ import division from __future__ import absolute_import import os from codechecker_common.logger import get_logger LOG = get_logger('system') def check_zlib(): """ Check if zlib compression is available. If wrong libraries are installed on the host machine it is possible the the compression fails which is required to store data into the database. """ try: import zlib zlib.compress('Compress this') return True except Exception as ex: LOG.error(str(ex)) LOG.error('Failed to import zlib module.')
from codechecker_common import util from codechecker_common.env import get_check_env from codechecker_server import instance_manager, server from codechecker_server.database import database from codechecker_server.database.config_db_model \ import IDENTIFIER as CONFIG_META from codechecker_server.database.config_db_model \ import Product as ORMProduct from codechecker_server.database.run_db_model \ import IDENTIFIER as RUN_META from codechecker_web.shared import webserver_context, database_status, \ host_check LOG = logger.get_logger('server') def get_argparser_ctor_args(): """ This method returns a dict containing the kwargs for constructing an argparse.ArgumentParser (either directly or as a subparser). """ return { 'prog': 'CodeChecker server', 'formatter_class': argparse.ArgumentDefaultsHelpFormatter, # Description is shown when the command's help is queried directly 'description': "The CodeChecker Web server is used to handle the " "storage and navigation of analysis results. A "