Implements full path for hash checks of binaries

[releng-anteater.git] / anteater / src / get_lists.py

diff --git a/anteater/src/get_lists.py b/anteater/src/get_lists.py
index 713321f..4eb1d3f 100644 (file)
--- a/anteater/src/get_lists.py
+++ b/anteater/src/get_lists.py
@@ -13,21 +13,27 @@
     Gathers various values from the gate check yaml file and return them to the
     calling instance
 """
+from __future__ import absolute_import
 
-import anteater.utils.anteater_logger as antlog
-import ConfigParser
+import logging
+import six.moves.configparser
 import copy
 import os
 import yaml
 import re
 
-config = ConfigParser.RawConfigParser()
+
+config = six.moves.configparser.RawConfigParser()
 config.read('anteater.conf')
-logger = antlog.Logger(__name__).getLogger()
+logger = logging.getLogger(__name__)
 master_list = config.get('config', 'master_list')
+ignore_list = config.get('config', 'ignore_list')
 
 with open(master_list, 'r') as f:
-    yl = yaml.safe_load(f)
+    ml = yaml.safe_load(f)
+
+with open(ignore_list, 'r') as f:
+    il = yaml.safe_load(f)
 
 
 def _remove_nullvalue(contents):
@@ -63,49 +69,43 @@ class GetLists(object):
             with open(exception_file, 'r') as f:
                 ex = yaml.safe_load(f)
             for key in ex:
-                if key in yl:
-                    yl[key][project] = _merge(yl[key][project], ex.get(key, None)) \
-                            if project in yl[key] else ex.get(key, None)
+                if key in ml:
+                    ml[key][project] = _merge(ml[key][project], ex.get(key, None)) \
+                            if project in ml[key] else ex.get(key, None)
             self.loaded = True
 
     def binary_list(self, project):
-        project_list = False
-        self.load_project_exception_file(yl.get('project_exceptions'), project)
         try:
-            default_list = (yl['binaries']['binary_ignore'])
+            default_list = (ml['binaries']['binary_ignore'])
         except KeyError:
             logger.error('Key Error processing binary list values')
-        try:
-            project_list = (yl['binaries'][project]['binary_ignore'])
-        except KeyError:
-            logger.info('No binary waivers found for {0}'.
-                        format(project))
 
         binary_re = re.compile("|".join(default_list),
-                flags=re.IGNORECASE)
+                               flags=re.IGNORECASE)
+        return binary_re
+
+    def binary_hash(self, project, patch_file):
+        self.load_project_exception_file(ml.get('project_exceptions'), project)
+        try:
+            binary_hash = (ml['binaries'][project][patch_file])
+            return binary_hash
+        except KeyError:
+            binary_hash = 'null'
+            return binary_hash
 
-        if project_list:
-            binary_project_re = re.compile("|".join(project_list),
-                                           flags=re.IGNORECASE)
-            return binary_re, binary_project_re
-        else:
-            binary_project_re = re.compile("")
-            return binary_re, binary_project_re
 
     def file_audit_list(self, project):
         project_list = False
-        self.load_project_exception_file(yl.get('project_exceptions'), project)
+        self.load_project_exception_file(ml.get('project_exceptions'), project)
         try:
-            default_list = set((yl['file_audits']['file_names']))
+            default_list = set((ml['file_audits']['file_names']))
         except KeyError:
             logger.error('Key Error processing file_names list values')
         try:
-            project_list = set((yl['file_audits'][project]['file_names']))
-            logger.info('file_names waivers found for {0}'.
-                        format(project))
+            project_list = set((ml['file_audits'][project]['file_names']))
+            logger.info('file_names waivers found for %s', project)
         except KeyError:
-            logger.info('No file_names waivers found for {0}'.
-                        format(project))
+            logger.info('No file_names waivers found for %s', project)
 
         file_names_re = re.compile("|".join(default_list),
                                    flags=re.IGNORECASE)
@@ -120,38 +120,48 @@ class GetLists(object):
 
     def file_content_list(self,  project):
         project_list = False
-        self.load_project_exception_file(yl.get('project_exceptions'), project)
+        self.load_project_exception_file(ml.get('project_exceptions'), project)
+        try:
+            master_list = (ml['file_audits']['file_contents'])
+
+        except KeyError:
+            logger.error('Key Error processing file_contents list values')
+
         try:
-            default_list = set((yl['file_audits']['file_contents']))
+            ignore_list = il['file_audits']['file_contents']
+
         except KeyError:
             logger.error('Key Error processing file_contents list values')
+
         try:
-            project_list = set((yl['file_audits'][project]['file_contents']))
+            project_list = ml['file_audits'][project]['file_contents']
+
         except KeyError:
-            logger.info('No file_contents waivers found  for {0}'.
-                        format(project))
+            logger.info('No file_contents waivers found  for %s', project)
 
-        file_contents_re = re.compile("|".join(default_list),
-                                      flags=re.IGNORECASE)
+        ignore_list_merge = project_list + ignore_list
 
-        if project_list:
-            file_contents_proj_re = re.compile("|".join(project_list),
-                                               flags=re.IGNORECASE)
-            return file_contents_re, file_contents_proj_re
-        else:
-            file_contents_proj_re = re.compile("")
-            return file_contents_re, file_contents_proj_re
+        ignore_list_re = re.compile("|".join(ignore_list_merge), flags=re.IGNORECASE)
+
+        return master_list, ignore_list_re
+
+    def file_ignore(self):
+        try:
+            file_ignore = (ml['file_ignore'])
+        except KeyError:
+            logger.error('Key Error processing file_ignore list values')
+        return file_ignore
 
     def licence_extensions(self):
         try:
-            licence_extensions = (yl['licence']['licence_ext'])
+            licence_extensions = (ml['licence']['licence_ext'])
         except KeyError:
             logger.error('Key Error processing licence_extensions list values')
         return licence_extensions
 
     def licence_ignore(self):
         try:
-            licence_ignore = (yl['licence']['licence_ignore'])
+            licence_ignore = (ml['licence']['licence_ignore'])
         except KeyError:
             logger.error('Key Error processing licence_ignore list values')
         return licence_ignore