anteater/src/get_lists.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 ##############################################################################
   4 # Copyright (c) 2017 Luke Hinds <lhinds@redhat.com>, Red Hat
   5 #
   6 # All rights reserved. This program and the accompanying materials
   7 # are made available under the terms of the Apache License, Version 2.0
   8 # which accompanies this distribution, and is available at
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10 ##############################################################################
  11
  12 """
  13     Gathers various values from the gate check yaml file and return them to the
  14     calling instance
  15 """
  16 from __future__ import absolute_import
  17
  18 import anteater.utils.anteater_logger as antlog
  19 import six.moves.configparser
  20 import copy
  21 import os
  22 import yaml
  23 import re
  24
  25
  26 config = six.moves.configparser.RawConfigParser()
  27 config.read('anteater.conf')
  28 logger = antlog.Logger(__name__).getLogger()
  29 master_list = config.get('config', 'master_list')
  30
  31 with open(master_list, 'r') as f:
  32     yl = yaml.safe_load(f)
  33
  34
  35 def _remove_nullvalue(contents):
  36     if contents and len(contents) > 2 and 'nullvalue' in contents:
  37         contents.remove('nullvalue')
  38
  39
  40 def _merge(org, ded):
  41     ret = copy.deepcopy(org)
  42     for key in list(set([k for k in org] + [k for k in ded])):
  43         if key in org and key in ded:
  44             ret[key] = list(set(ret[key] + ded[key]))
  45             _remove_nullvalue(ret[key])
  46         elif key in ded:
  47             ret[key] = ded[key]
  48     return ret
  49
  50
  51 class GetLists(object):
  52     def __init__(self, *args):
  53         # Placeholder for future args if more filters are needed
  54         self.args = args
  55         self.loaded = False
  56
  57     def load_project_exception_file(self, project_exceptions, project):
  58         if self.loaded:
  59             return
  60         exception_file = None
  61         for item in project_exceptions:
  62             if project in item:
  63                 exception_file = item.get(project)
  64         if exception_file is not None:
  65             with open(exception_file, 'r') as f:
  66                 ex = yaml.safe_load(f)
  67             for key in ex:
  68                 if key in yl:
  69                     yl[key][project] = _merge(yl[key][project], ex.get(key, None)) \
  70                             if project in yl[key] else ex.get(key, None)
  71             self.loaded = True
  72
  73     def binary_list(self, project):
  74         try:
  75             default_list = (yl['binaries']['binary_ignore'])
  76         except KeyError:
  77             logger.error('Key Error processing binary list values')
  78
  79         binary_re = re.compile("|".join(default_list),
  80                                flags=re.IGNORECASE)
  81         return binary_re
  82
  83     def binary_hash(self, project, patch_file):
  84         self.load_project_exception_file(yl.get('project_exceptions'), project)
  85         file_name = os.path.basename(patch_file)
  86         try:
  87             binary_hash = (yl['binaries'][project][file_name])
  88             return binary_hash
  89         except KeyError:
  90             logger.info('No checksum entries found for {0}'.
  91                         format(file_name))
  92             binary_hash = 'null'
  93             return binary_hash
  94
  95
  96     def file_audit_list(self, project):
  97         project_list = False
  98         self.load_project_exception_file(yl.get('project_exceptions'), project)
  99         try:
 100             default_list = set((yl['file_audits']['file_names']))
 101         except KeyError:
 102             logger.error('Key Error processing file_names list values')
 103         try:
 104             project_list = set((yl['file_audits'][project]['file_names']))
 105             logger.info('file_names waivers found for {0}'.
 106                         format(project))
 107         except KeyError:
 108             logger.info('No file_names waivers found for {0}'.
 109                         format(project))
 110
 111         file_names_re = re.compile("|".join(default_list),
 112                                    flags=re.IGNORECASE)
 113
 114         if project_list:
 115             file_names_proj_re = re.compile("|".join(project_list),
 116                                             flags=re.IGNORECASE)
 117             return file_names_re, file_names_proj_re
 118         else:
 119             file_names_proj_re = re.compile("")
 120             return file_names_re, file_names_proj_re
 121
 122     def file_content_list(self,  project):
 123         project_list = False
 124         self.load_project_exception_file(yl.get('project_exceptions'), project)
 125         try:
 126             default_list = set((yl['file_audits']['file_contents']))
 127         except KeyError:
 128             logger.error('Key Error processing file_contents list values')
 129         try:
 130             project_list = set((yl['file_audits'][project]['file_contents']))
 131         except KeyError:
 132             logger.info('No file_contents waivers found  for {0}'.
 133                         format(project))
 134
 135         file_contents_re = re.compile("|".join(default_list),
 136                                       flags=re.IGNORECASE)
 137
 138         if project_list:
 139             file_contents_proj_re = re.compile("|".join(project_list),
 140                                                flags=re.IGNORECASE)
 141             return file_contents_re, file_contents_proj_re
 142         else:
 143             file_contents_proj_re = re.compile("")
 144             return file_contents_re, file_contents_proj_re
 145
 146     def licence_extensions(self):
 147         try:
 148             licence_extensions = (yl['licence']['licence_ext'])
 149         except KeyError:
 150             logger.error('Key Error processing licence_extensions list values')
 151         return licence_extensions
 152
 153     def licence_ignore(self):
 154         try:
 155             licence_ignore = (yl['licence']['licence_ignore'])
 156         except KeyError:
 157             logger.error('Key Error processing licence_ignore list values')
 158         return licence_ignore