# ------------------------------------------------------------------------- import ntpath import os import zlib from abc import ABCMeta import shared from codechecker_lib import client from codechecker_lib import logger from codechecker_lib import plist_parser from codechecker_lib import suppress_handler from codechecker_lib.analyzers.result_handler_base import ResultHandler LOG = logger.get_new_logger('PLIST TO DB') class PlistToDB(ResultHandler): """ Result handler for processing a plist file with the analysis results and stores them to the database. """ __metaclass__ = ABCMeta def __init__(self, buildaction, workspace, run_id): super(PlistToDB, self).__init__(buildaction, workspace) self.__run_id = run_id def __store_bugs(self, files, bugs, connection, analisys_id):
# The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import os import sys import json from codechecker_lib import context_base from codechecker_lib import logger from codechecker_lib import db_version from codechecker_lib.analyzers import analyzer_types LOG = logger.get_new_logger('CONTEXT') # ----------------------------------------------------------------------------- class Context(context_base.ContextBase): ''' generic package specific context''' __instance = None logger_bin = None logger_file = None logger_compilers = None ld_preload = None __package_version = None __package_root = None
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- from codechecker_lib import logger from codechecker_lib import tidy_output_converter from codechecker_lib.analyzers.result_handler_plist_to_db import PlistToDB from codechecker_lib.analyzers.result_handler_plist_to_stdout import \ PlistToStdout LOG = logger.get_new_logger('CLANG_TIDY_RESULT_HANDLER') def generate_plist_from_tidy_result(output_file, tidy_stdout): """ Generate a plist file from the clang tidy analyzer results. """ parser = tidy_output_converter.OutputParser() messages = parser.parse_messages(tidy_stdout) plist_converter = tidy_output_converter.PListConverter() plist_converter.add_messages(messages) plist_converter.write_to_file(output_file) class ClangTidyPlistToDB(PlistToDB):
def __init__(self, context, analyzer_env): self._context = context self._analyzer_env = analyzer_env self._logger = logger.get_new_logger('ANALYZER_CRASH_HANDLER')
"root", "myname" ], "groups": [ "adm", "cc-users" ] } """ import pam import grp import pwd from codechecker_lib import logger LOG = logger.get_new_logger("PAM") def auth_user(pam_config, username, password): """ Authenticate user with PAM. """ LOG.debug('Authenticating user with PAM.') auth = pam.pam() if auth.authenticate(username, password): allowed_users = pam_config.get("users") \ or [] allowed_group = pam_config.get("groups")\ or []
# The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """ build and log related stuff """ import os import pickle import subprocess import sys from codechecker_lib import logger from codechecker_lib import analyzer_env LOG = logger.get_new_logger('BUILD MANAGER') def execute_buildcmd(command, silent=False, env=None, cwd=None): """ Execute the the build command and continously 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)
# The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- '''''' import os import sys import signal import subprocess import ntpath from codechecker_lib import client from codechecker_lib import logger from codechecker_lib import analyzer_env LOG = logger.get_new_logger('ANALYZER') # ----------------------------------------------------------------------------- class StaticAnalyzer(object): '''''' def __init__(self, context): self._context = context # Load all plugin from plugin directory plugin_dir = os.path.join(context.package_root, context.checker_plugin) self._plugins = [os.path.join(plugin_dir, f) for f in os.listdir(plugin_dir) if os.path.isfile(os.path.join(plugin_dir, f))] self._config = None self._skip = []
# ------------------------------------------------------------------------- import os import sys import sqlalchemy from sqlalchemy.sql import and_ from codechecker_lib import analyzer_crash_handler from codechecker_lib import analyzer_env from codechecker_lib import database_handler from codechecker_lib import logger from db_model.orm_model import BuildAction from db_model.orm_model import Run LOG = logger.get_new_logger('DEBUG_REPORTER') # ----------------------------------------------------------------------------- def get_dump_file_name(run_id, action_id): return 'action_' + str(run_id) + '_' + str(action_id) + '_dump.log' # ----------------------------------------------------------------------------- def debug(context, connection_string, force): try: engine = database_handler.SQLServer.create_engine(connection_string) session = sqlalchemy.orm.scoped_session( sqlalchemy.orm.sessionmaker(bind=engine)) # Get latest run id.
''' import zlib import os import datetime from collections import defaultdict import ntpath import codecs import shared from Authentication import constants from Authentication.ttypes import * from codechecker_lib import logger from codechecker_lib import session_manager LOG = logger.get_new_logger('AUTH HANDLER') # ----------------------------------------------------------------------- def timefunc(function): ''' timer function ''' func_name = function.__name__ def debug_wrapper(*args, **kwargs): ''' wrapper for debug log ''' before = datetime.now()
import copy import json import os import shlex import subprocess import sys import time from codechecker_lib import analysis_manager from codechecker_lib import client from codechecker_lib import logger from codechecker_lib import skiplist_handler from codechecker_lib import analyzer_env from codechecker_lib.analyzers import analyzer_types LOG = logger.get_new_logger('ANALYZER') def prepare_actions(actions, enabled_analyzers): """ Set the analyzer type for each buildaction. Multiple actions if multiple source analyzers are set. """ res = [] for ea in enabled_analyzers: for action in actions: new_action = copy.deepcopy(action) new_action.analyzer_type = ea res.append(new_action) return res
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import os import traceback from codechecker_lib import build_action from codechecker_lib import logger from codechecker_lib import option_parser LOG = logger.get_new_logger('LOG PARSER') # ----------------------------------------------------------------------------- def parse_compile_commands_json(logfile): import json actions = [] filtered_build_actions = {} logfile.seek(0) data = json.load(logfile) counter = 0 for entry in data: sourcefile = entry['file'] lang = option_parser.get_language(sourcefile[sourcefile.rfind('.'):])
from codechecker_lib import generic_package_context from codechecker_lib import analyzer from codechecker_lib import log_parser from codechecker_lib import util from codechecker_lib import debug_reporter from codechecker_lib import logger from codechecker_lib import analyzer_env from codechecker_lib import host_check from codechecker_lib import generic_package_suppress_handler from codechecker_lib.database_handler import SQLServer from codechecker_lib import build_manager from codechecker_lib.analyzers import analyzer_types LOG = logger.get_new_logger('ARG_HANDLER') def handle_list_checkers(args): """ list the supported checkers by the analyzers list the default enabled and disabled checkers in the config """ context = generic_package_context.get_context() enabled_analyzers = args.analyzers analyzer_environment = analyzer_env.get_check_env( context.path_env_extra, context.ld_lib_path_extra) if not enabled_analyzers: # noting set list checkers for all supported analyzers
# This is the new format. 123324353456463442341242342343#1 || filename || bug hash comment After removing the hash_value_type the generated format is: 123324353456463442341242342343 || filename || bug hash comment For backward compatibility the hash_value_type is an optional filed. """ import codecs import os import re from codechecker_lib import logger LOG = logger.get_new_logger('SUPPRESS_FILE_HANDLER') COMMENT_SEPARATOR = '||' HASH_TYPE_SEPARATOR = '#' def get_suppress_data(suppress_file): """ Process a file object for suppress information. """ old_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<comment>[^\|]*)$" old_format = re.compile(old_format_pattern, re.UNICODE) new_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<file_name>[^\\\|]+)\s*\|\|\s*(?P<comment>[^\|]*)$" new_format = re.compile(new_format_pattern, re.UNICODE)
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import os import uuid import ntpath from abc import ABCMeta, abstractmethod from codechecker_lib import logger LOG = logger.get_new_logger('RESULT_HANDLER_BASE') class ResultHandler(object): """ handle and store the results at runtime for the analyzer stdout, stderr, temporarly generated files do result postprocessing if required For each buildaction there is one result handler the result handler can handle multiple results if there are more than one analyzed source file in one buildaction For each build action - postprocess_result and handle_results can be called multiple times for the source files in one buildaction they will be analyzed separately with the same build options
from codechecker_lib import pgpass from codechecker_lib import host_check from db_model.orm_model import CC_META from db_model.orm_model import DBVersion from db_model.orm_model import CreateSession import sqlalchemy from sqlalchemy.engine.url import URL, make_url from sqlalchemy.sql.elements import quoted_name from sqlalchemy.engine import Engine from sqlalchemy import event from alembic import command, config LOG = logger.get_new_logger('DB_HANDLER') class SQLServer(object): ''' Abstract base class for database server handling. An SQLServer instance is responsible for the initialization, starting, and stopping the database server, and also for connection string management. SQLServer implementations are created via SQLServer.from_cmdline_args(). How to add a new database server implementation: 1, Derive from SQLServer and implement the abstract methods 2, Add/modify some command line options in CodeChecker.py 3, Modify SQLServer.from_cmdline_args() in order to create an instance of the new server type if needed
# This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import os import sys import sqlalchemy from db_model.orm_model import * from codechecker_lib import analyzer_env from codechecker_lib import logger from codechecker_lib import analyzer_crash_handler LOG = logger.get_new_logger('DEBUG_REPORTER') # ----------------------------------------------------------------------------- def get_dump_file_name(run_id, action_id): return 'action_' + str(run_id) + '_' + str(action_id) + '_dump.log' # ----------------------------------------------------------------------------- def debug(context, dbusername, dbhost, dbport, dbname, force): try: connection_string = 'postgres://' + dbusername + '@' + dbhost + ':' + \ str(dbport) + '/' + dbname engine = sqlalchemy.create_engine(connection_string) print(connection_string) session = sqlalchemy.orm.scoped_session(
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """ Handler for suppressing a bug. """ from codechecker_lib import logger from codechecker_lib import suppress_file_handler from codechecker_lib import suppress_handler # Warning! this logger should only be used in this module. LOG = logger.get_new_logger('SUPPRESS') class GenericSuppressHandler(suppress_handler.SuppressHandler): def store_suppress_bug_id(self, bug_id, file_name, comment): if self.suppress_file is None: return False ret = suppress_file_handler.write_to_suppress_file( self.suppress_file, bug_id, file_name, comment) return ret def remove_suppress_bug_id(self, bug_id, file_name): if self.suppress_file is None: return False
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- ''' handler for suppressing a bug ''' from codechecker_lib import logger from codechecker_lib import suppress_handler from codechecker_lib import suppress_file_handler # Warning! this logger should only be used in this module LOG = logger.get_new_logger('SUPPRESS') class GenericSuppressHandler(suppress_handler.SuppressHandler): def store_suppress_bug_id(self, source_file_path, bug_id, hash_type, comment): if self.suppress_file is None: return True ret = suppress_file_handler.write_to_suppress_file(self.suppress_file, bug_id, hash_type, comment) return ret def remove_suppress_bug_id(self, source_file_path, bug_id, hash_type):
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import re from codechecker_lib import logger from codechecker_lib.analyzers import config_handler LOG = logger.get_new_logger("CLANGSA CONFIG HANDLER") class ClangSAConfigHandler(config_handler.AnalyzerConfigHandler): """ Configuration handler for the clang static analyzer. """ def __init__(self): super(ClangSAConfigHandler, self).__init__() self.__checker_configs = [] def add_checker_config(self, config): """ Add a (checker_name, key, value) tuple to the list. """ self.__checker_configs.append(config) def get_checker_configs(self): """
from alembic.util import CommandError from alembic import command, config from sqlalchemy import event from sqlalchemy.engine import Engine from sqlalchemy.engine.url import URL, make_url from sqlalchemy.sql.elements import quoted_name from codechecker_lib import host_check from codechecker_lib import logger from codechecker_lib import pgpass from codechecker_lib import util from db_model.orm_model import CC_META from db_model.orm_model import CreateSession from db_model.orm_model import DBVersion LOG = logger.get_new_logger('DB_HANDLER') class SQLServer(object): """ Abstract base class for database server handling. An SQLServer instance is responsible for the initialization, starting, and stopping the database server, and also for connection string management. SQLServer implementations are created via SQLServer.from_cmdline_args(). How to add a new database server implementation: 1, Derive from SQLServer and implement the abstract methods 2, Add/modify some command line options in CodeChecker.py 3, Modify SQLServer.from_cmdline_args() in order to create an instance of the new server type if needed
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """""" import os from codechecker_lib import logger LOG = logger.get_new_logger('ENV') # ------------------------------------------------------------------------------ def get_log_env(logfile, context, original_env): """ Environment for logging. With the ld logger. Keep the original environment unmodified as possible. Only environment variables required for logging are changed. """ new_env = original_env new_env[context.env_var_cc_logger_bin] = context.path_logger_bin new_env['LD_PRELOAD'] = context.logger_lib_name try: original_ld_library_path = new_env['LD_LIBRARY_PATH'] new_env['LD_LIBRARY_PATH'] = context.path_logger_lib + ':' + \ original_ld_library_path
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import re import json import shlex import argparse from codechecker_lib.analyzers import config_handler from codechecker_lib import logger LOG = logger.get_new_logger('CLANG TIDY CONFIG') class ClangTidyConfigHandler(config_handler.AnalyzerConfigHandler): ''' Configuration handler for Clang-tidy analyzer ''' def __init__(self): super(ClangTidyConfigHandler, self).__init__() def get_checker_configs(self): """ process the raw extra analyzer arguments and get the configuration data ('-config=' argument for Clang tidy) for the checkers Clang tidy accepts YAML or JSON formatted config, right now
from DBThriftAPI import CheckerReport from DBThriftAPI.ttypes import * from thrift import Thrift from thrift.transport import TSocket from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from codechecker_lib import logger from codechecker_lib import plist_parser from codechecker_lib import database_handler from codechecker_lib import util from codechecker_lib import suppress_file_handler from codechecker_lib import suppress_handler LOG = logger.get_new_logger('CLIENT') # ----------------------------------------------------------------------------- def send_plist_content(connection, plist_file, build_action_id, run_id, severity_map, should_skip): try: files, bugs = plist_parser.parse_plist(plist_file) except Exception: LOG.info('The generated plist is not valid, so parsing failed.') return file_ids = {} # Send content of file to the server if needed for file_name in files: file_descriptor = connection.need_file_content(file_name)
from codechecker_lib import logger unsupported_methods = [] try: from codechecker_lib.auth import cc_ldap except ImportError: unsupported_methods.append("ldap") try: from codechecker_lib.auth import cc_pam except ImportError: unsupported_methods.append("pam") LOG = logger.get_new_logger("SESSION MANAGER") SESSION_COOKIE_NAME = "__ccPrivilegedAccessToken" session_lifetimes = {} # ------------------------------ # ----------- SERVER ----------- class _Session(): """A session for an authenticated, privileged client connection.""" # Create an initial salt from system environment for use with the session # permanent persistency routine. __initial_salt = hashlib.sha256(SESSION_COOKIE_NAME + "__" + str(time.time()) + "__" + os.urandom(16)).hexdigest()
from thrift.transport import TSocket from thrift.transport import TTransport from thrift.transport import TZlibTransport from thrift.protocol import TBinaryProtocol from thrift.server import TServer from thrift.server import TProcessPoolServer from codechecker_gen.DBThriftAPI import CheckerReport from codechecker_gen.DBThriftAPI.ttypes import * from db_model.orm_model import * from codechecker_lib import logger from codechecker_lib import decorators LOG = logger.get_new_logger("CC SERVER") # ----------------------------------------------------------------------- if os.environ.get("CODECHECKER_ALCHEMY_LOG") is not None: import logging logging.basicConfig() logging.getLogger("sqlalchemy.engine").setLevel(logging.DEBUG) logging.getLogger("sqlalchemy.orm").setLevel(logging.DEBUG) # ----------------------------------------------------------------------- class CheckerReportHandler(object): """ Class to handle requests from the codechecker script to store run information to the database
# this is the new format 123324353456463442341242342343#1 || filename || bug hash comment after removing the hash_value_type the generated format is: 123324353456463442341242342343 || filename || bug hash comment for backward compatibility the hash_value_type is an optional filed ''' import re import os import string import codecs from codechecker_lib import logger LOG = logger.get_new_logger('SUPPRESS_FILE_HANDLER') COMMENT_SEPARATOR = '||' HASH_TYPE_SEPARATOR = '#' def get_suppress_data(suppress_file): """ processs a file object for suppress information """ old_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<comment>[^\|]*)$" old_format = re.compile(old_format_pattern, re.UNICODE) new_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<file_name>[^\\\|]+)\s*\|\|\s*(?P<comment>[^\|]*)$"
''' import datetime import os import hashlib import ntpath import sys import glob import socket import shutil import subprocess from codechecker_lib import logger # WARNING! LOG should be only used in this module LOG = logger.get_new_logger('UTIL') # --------------------------------------------------------------------- def get_free_port(): ''' get a free port from the os''' s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(('', 0)) free_port = s.getsockname()[1] s.close() return free_port # ---------------------------------------------------------------------
# This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- ''' This module is responsible for parsing clang-tidy output and generating plist for the plist_parser module. ''' import re import os import copy import plistlib from codechecker_lib import logger LOG = logger.get_new_logger('TIDY_OUTPUT_HANDLER') 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. # ------------------------------------------------------------------------- import ntpath import os import uuid from abc import ABCMeta, abstractmethod from codechecker_lib import logger LOG = logger.get_new_logger('RESULT_HANDLER_BASE') class ResultHandler(object): """ Handle and store the results at runtime for the analyzer: stdout, stderr, temporarily generated files. Do result postprocessing if required. For each buildaction there is one result handler. The result handler can handle multiple results if there are more than one analyzed source file in one buildaction. handle_results() handles the results of a static analysis tool processed on a build action. Alternatively one can also handle results given by plist files for which handle_plist() can be used. For each build action
import zlib import os from collections import defaultdict import ntpath import codecs import shared from Authentication import constants from Authentication.ttypes import * from codechecker_lib import logger from codechecker_lib import session_manager from codechecker_lib.profiler import timeit LOG = logger.get_new_logger('AUTH HANDLER') def conv(text): ''' Convert * to % got from clients for the database queries. ''' if text is None: return '%' return text.replace('*', '%') class ThriftAuthHandler(): ''' Handle Thrift authentication requests. '''
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import re import shlex import subprocess from codechecker_lib import logger from codechecker_lib.analyzers import analyzer_base LOG = logger.get_new_logger('CLANGSA') class ClangSA(analyzer_base.SourceAnalyzer): """ Constructs clang static analyzer commands. """ def __parse_checkers(self, clangsa_output): """ Parse clang static analyzer checkers, store them to checkers. """ # Checker name and description in one line. pattern = re.compile( r'^\s\s(?P<checker_name>\S*)\s*(?P<description>.*)') checker_name = None
import multiprocessing import ntpath import os import re import shutil import signal import sys import traceback from collections import defaultdict from codechecker_lib import analyzer_env from codechecker_lib import logger from codechecker_lib.analyzers import analyzer_types LOG = logger.get_new_logger('ANALYSIS MANAGER') def worker_result_handler(results): """ Print the analysis summary. """ successful_analysis = defaultdict(int) failed_analysis = defaultdict(int) skipped_num = 0 for res, skipped, analyzer_type in results: if skipped: skipped_num += 1 else:
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import os import sys import json from codechecker_lib import context_base from codechecker_lib import logger from codechecker_lib import db_version LOG = logger.get_new_logger('CONTEXT') # ----------------------------------------------------------------------------- class Context(context_base.ContextBase): ''' generic package specific context''' __instance = None logger_bin = None logger_file = None logger_compilers = None ld_preload = None __package_version = None __package_root = None def __init__(self, package_root, pckg_layout, cfg_dict):
Used to filter out or change compiler argument not supported by clang or clang-tidy. Keys are the option name, value is the number of options to skip. Possible improvements: - modular option handling system configuring possibility from config file """ import os import re import shlex from codechecker_lib import logger LOG = logger.get_new_logger('OPTION PARSER') # Compiler options. COMPILE_OPTION_MAP = { '-idirafter': 1, '-imacros': 1, '-include': 1, '-iprefix': 1, '-isysroot': 1, '-isystem': 1, '-iwithprefix': 1, '-iwithprefixbefore': 1, '-nostdinc': 0, '-sysroot': 1 }
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import collections import os from abc import ABCMeta, abstractmethod from codechecker_lib import logger LOG = logger.get_new_logger('CONFIG HANDLER') class AnalyzerConfigHandler(object): """ Handle the checker configurations and enabled disabled checkers lists. """ __metaclass__ = ABCMeta def __init__(self): self.__analyzer_binary = None self.__analyzer_plugins_dir = None self.__compiler_sysroot = None self.__compiler_resource_dirs = [] self.__sys_inc = [] self.__includes = [] self.__analyzer_extra_arguments = ''
# ------------------------------------------------------------------------- import os import sys import math import ntpath import linecache from abc import ABCMeta from codechecker_lib import logger from codechecker_lib import plist_parser from codechecker_lib.analyzers.result_handler_base import ResultHandler LOG = logger.get_new_logger('PLIST TO STDOUT') class PlistToStdout(ResultHandler): """ Result handler for processing a plist file with the analysis results and print them to the standard output. """ __metaclass__ = ABCMeta def __init__(self, buildaction, workspace): super(PlistToStdout, self).__init__(buildaction, workspace) self.__print_steps = False self.__output = sys.stdout
import sys from codechecker_lib import logger from codechecker_lib import analyzer_env from codechecker_lib import host_check from codechecker_lib import client from codechecker_lib.analyzers import analyzer_clangsa from codechecker_lib.analyzers import config_handler_clangsa from codechecker_lib.analyzers import result_handler_clangsa from codechecker_lib.analyzers import analyzer_clang_tidy from codechecker_lib.analyzers import result_handler_clang_tidy from codechecker_lib.analyzers import config_handler_clang_tidy LOG = logger.get_new_logger('ANALYZER TYPES') CLANG_SA = 'clangsa' CLANG_TIDY = 'clang-tidy' supported_analyzers = {CLANG_SA, CLANG_TIDY} def is_sa_checker_name(checker_name): """ match for Clang Static analyzer names like unix unix.Malloc security.insecureAPI security.insecureAPI.gets
from codechecker_lib import build_action from codechecker_lib import build_manager from codechecker_lib import client from codechecker_lib import debug_reporter from codechecker_lib import generic_package_context from codechecker_lib import generic_package_suppress_handler from codechecker_lib import host_check from codechecker_lib import log_parser from codechecker_lib import logger from codechecker_lib import session_manager from codechecker_lib import util from codechecker_lib.analyzers import analyzer_types from codechecker_lib.database_handler import SQLServer from viewer_server import client_db_access_server LOG = logger.get_new_logger('ARG_HANDLER') def handle_list_checkers(args): """ List the supported checkers by the analyzers. List the default enabled and disabled checkers in the config. """ context = generic_package_context.get_context() enabled_analyzers = args.analyzers analyzer_environment = analyzer_env.get_check_env(context.path_env_extra, context.ld_lib_path_extra) if not enabled_analyzers: # Noting set list checkers for all supported analyzers. enabled_analyzers = list(analyzer_types.supported_analyzers)
from codechecker_gen.DBThriftAPI import CheckerReport from codechecker_gen.DBThriftAPI.ttypes import * from thrift.protocol import TBinaryProtocol from thrift.server import TServer from thrift.transport import TSocket from thrift.transport import TTransport from codechecker_lib import database_handler from codechecker_lib import decorators from codechecker_lib import logger from db_model.orm_model import * from codechecker_lib.profiler import timeit from codechecker_lib.profiler import profileit LOG = logger.get_new_logger('CC SERVER') if os.environ.get('CODECHECKER_ALCHEMY_LOG') is not None: import logging logging.basicConfig() logging.getLogger('sqlalchemy.engine').setLevel(logging.DEBUG) logging.getLogger('sqlalchemy.orm').setLevel(logging.DEBUG) class CheckerReportHandler(object): """ Class to handle requests from the CodeChecker script to store run information to the database. """ def __sequence_deleter(self, table, first_id):
# The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """""" # FIXME: This file contains some workarounds. # Remove them as soon as a proper clang version comes out. import plistlib from xml.parsers.expat import ExpatError from codechecker_lib import logger from . import plist_helper LOG = logger.get_new_logger('PLIST_PARSER') class GenericEquality(object): def __eq__(self, other): return (isinstance(other, self.__class__) and self.__dict__ == other.__dict__) def __ne__(self, other): return not self.__eq__(other) # ----------------------------------------------------------------------------- class Position(GenericEquality):
import shared from codeCheckerDBAccess import codeCheckerDBAccess from codeCheckerDBAccess import constants from codeCheckerDBAccess.ttypes import * from Authentication import codeCheckerAuthentication from Authentication import constants from Authentication.ttypes import * from client_db_access_handler import ThriftRequestHandler from client_auth_handler import ThriftAuthHandler from codechecker_lib import logger from codechecker_lib import database_handler from codechecker_lib import session_manager LOG = logger.get_new_logger('DB ACCESS') class RequestHandler(SimpleHTTPRequestHandler): """ Handle thrift and browser requests Simply modified and extended version of SimpleHTTPRequestHandler """ def __init__(self, request, client_address, server): self.sc_session = server.sc_session self.db_version_info = server.db_version_info self.manager = server.manager BaseHTTPRequestHandler.__init__(self,
import codecs import sqlalchemy from sqlalchemy import asc, desc from sqlalchemy.sql import or_, and_, func from sqlalchemy.sql.expression import literal_column from db_model.orm_model import * import shared from codeCheckerDBAccess import constants from codeCheckerDBAccess.ttypes import * from codechecker_lib import logger LOG = logger.get_new_logger('ACCESS HANDLER') # ----------------------------------------------------------------------- def timefunc(function): ''' timer function ''' func_name = function.__name__ def debug_wrapper(*args, **kwargs): ''' wrapper for debug log ''' before = datetime.now()
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import argparse import json import re import shlex from codechecker_lib import logger from codechecker_lib.analyzers import config_handler LOG = logger.get_new_logger("CLANG TIDY CONFIG") class ClangTidyConfigHandler(config_handler.AnalyzerConfigHandler): """ Configuration handler for Clang-tidy analyzer. """ def __init__(self): super(ClangTidyConfigHandler, self).__init__() def get_checker_configs(self): """ Process the raw extra analyzer arguments and get the configuration data ('-config=' argument for Clang tidy) for the checkers. Clang tidy accepts YAML or JSON formatted config, right now
import os import re import sys from codechecker_lib import analyzer_env from codechecker_lib import client from codechecker_lib import host_check from codechecker_lib import logger from codechecker_lib.analyzers import analyzer_clang_tidy from codechecker_lib.analyzers import analyzer_clangsa from codechecker_lib.analyzers import config_handler_clang_tidy from codechecker_lib.analyzers import config_handler_clangsa from codechecker_lib.analyzers import result_handler_clang_tidy from codechecker_lib.analyzers import result_handler_clangsa LOG = logger.get_new_logger('ANALYZER TYPES') CLANG_SA = 'clangsa' CLANG_TIDY = 'clang-tidy' supported_analyzers = {CLANG_SA, CLANG_TIDY} def is_sa_checker_name(checker_name): """ Match for Clang Static analyzer names like: - unix - unix.Malloc - security.insecureAPI - security.insecureAPI.gets """
# The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- import os import sys import shlex import signal import subprocess from abc import ABCMeta, abstractmethod from codechecker_lib import logger LOG = logger.get_new_logger('ANALYZER_BASE') class SourceAnalyzer(object): """ base class for different source analyzers """ __metaclass__ = ABCMeta def __init__(self, config_handler, buildaction): self.__config_handler = config_handler self.__buildaction = buildaction self.__source_file = '' self.__checkers = []
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """ """ import fnmatch import re from codechecker_lib import logger LOG = logger.get_new_logger('SKIPLIST_HANDLER') class SkipListHandler(object): """ Skiplist file format: -/skip/all/source/in/directory* -/do/not/check/this.file +/dir/check.this.file -/dir/* """ def __init__(self, skip_file): """ read up the skip file """ self.__skip = []
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- ''' suppress handling ''' import re import abc import linecache from codechecker_lib import logger LOG = logger.get_new_logger('SUPPRESS HANDLER') class SuppressHandler(object): """ suppress handler base class """ __metaclass__ = abc.ABCMeta __suppressfile = None @abc.abstractmethod def store_suppress_bug_id(self, source_file_path, bug_id, file_name, comment):
import sys import sqlalchemy from sqlalchemy import asc, desc from sqlalchemy.sql import or_, and_, func from sqlalchemy.sql.expression import literal_column from db_model.orm_model import * import shared from codeCheckerDBAccess import constants from codeCheckerDBAccess.ttypes import * from codechecker_lib import logger LOG = logger.get_new_logger('ACCESS HANDLER') # ----------------------------------------------------------------------- def timefunc(function): ''' timer function ''' func_name = function.__name__ def debug_wrapper(*args, **kwargs): ''' wrapper for debug log ''' before = datetime.now()
import os import sys import signal import multiprocessing import ntpath import traceback import shutil from collections import defaultdict from codechecker_lib import logger from codechecker_lib import analyzer_env from codechecker_lib.analyzers import analyzer_types LOG = logger.get_new_logger('ANALISYS MANAGER') def worker_result_handler(results): """ print the analisys summary """ successful_analysis = defaultdict(int) failed_analisys = defaultdict(int) skipped_num = 0 for res, skipped, analyzer_type in results: if skipped: skipped_num += 1 else:
# ------------------------------------------------------------------------- # The CodeChecker Infrastructure # This file is distributed under the University of Illinois Open Source # License. See LICENSE.TXT for details. # ------------------------------------------------------------------------- """ """ import re import shlex import subprocess from codechecker_lib import logger from codechecker_lib.analyzers import analyzer_base LOG = logger.get_new_logger('CLANG TIDY') class ClangTidy(analyzer_base.SourceAnalyzer): """ Constructs the clang tidy analyzer commands. """ def __parse_checkers(self, tidy_output): """ Parse clang tidy checkers list. Skip clang static analyzer checkers. Store them to checkers. """ for line in tidy_output.splitlines(): line = line.strip()
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler from SimpleHTTPServer import SimpleHTTPRequestHandler from thrift.transport import TTransport from thrift.protocol import TJSONProtocol from codeCheckerDBAccess import codeCheckerDBAccess from codeCheckerDBAccess.ttypes import * from client_db_access_handler import ThriftRequestHandler from codechecker_lib import logger from codechecker_lib import database_handler LOG = logger.get_new_logger('DB ACCESS') class RequestHander(SimpleHTTPRequestHandler): ''' Handle thrift and browser requests Simply modified and extended version of SimpleHTTPRequestHandler ''' def __init__(self, request, client_address, server): self.sc_session = server.sc_session self.db_version_info = server.db_version_info BaseHTTPRequestHandler.__init__(self, request, client_address, server)