Log the filename of a skipped block

Author: Joshua Rogers

gixy/parser/nginx_parser.py

@@ -50,45 +50,51 @@ def parse(self, content, root=None, path_info=None):
             #  Were parse nginx dump
             LOG.info("Switched to parse nginx configuration dump.")
             root_filename = self._prepare_dump(parsed)
+            path_info = root_filename
             self.is_dump = True
             self.cwd = os.path.dirname(root_filename)
             parsed = self.configs[root_filename]
 
-        self.parse_block(parsed, root)
+        self.parse_block(parsed, root, path_info)
         return root
 
-    def parse_block(self, parsed_block, parent):
+    def parse_block(self, parsed_block, parent, path_info):
         for parsed in parsed_block:
             parsed_type = parsed.getName()
+            line = parsed.get('line', None)
             parsed_name = parsed[0]
+            parsed_info = {parsed_name: line}
             parsed_args = parsed[1:]
             if parsed_type == "include":
                 # TODO: WTF?!
-                self._resolve_include(parsed_args, parent)
+                self._resolve_include(parsed_args, parent, path_info)
             else:
                 directive_inst = self.directive_factory(
-                    parsed_type, parsed_name, parsed_args
+                    parsed_type, parsed_info, parsed_args, path_info
                 )
                 if directive_inst:
                     parent.append(directive_inst)
 
-    def directive_factory(self, parsed_type, parsed_name, parsed_args):
-        klass = self._get_directive_class(parsed_type, parsed_name)
+    def directive_factory(self, parsed_type, parsed_info, parsed_args, path_info):
+        klass = self._get_directive_class(parsed_type, parsed_info, path_info)
         if not klass:
             return None
 
+        parsed_name = list(parsed_info.keys())[0]
         if klass.is_block:
             args = [to_native(v).strip() for v in parsed_args[0]]
             children = parsed_args[1]
 
             inst = klass(parsed_name, args)
-            self.parse_block(children, inst)
+            self.parse_block(children, inst, path_info)
             return inst
         else:
             args = [to_native(v).strip() for v in parsed_args]
             return klass(parsed_name, args)
 
-    def _get_directive_class(self, parsed_type, parsed_name):
+    def _get_directive_class(self, parsed_type, parsed_info, path_info):
+        parsed_name = list(parsed_info.keys())[0]
+        parsed_line = parsed_info.get(parsed_name, '<unknown>')
         if (
             parsed_type in self.directives
             and parsed_name in self.directives[parsed_type]
@@ -99,7 +105,7 @@ def _get_directive_class(self, parsed_type, parsed_name):
         elif parsed_type == "directive":
             return directive.Directive
         elif parsed_type == "unparsed_block":
-            LOG.warning('Skip unparseable block: "%s"', parsed_name)
+            LOG.warning('Skip unparseable block in %s beginning at line %s: "%s"', path_info, parsed_line, parsed_name)
             return None
         else:
             return None
@@ -108,7 +114,7 @@ def _init_directives(self):
         self.directives["block"] = block.get_overrides()
         self.directives["directive"] = directive.get_overrides()
 
-    def _resolve_include(self, args, parent):
+    def _resolve_include(self, args, parent, path_info):
         pattern = args[0]
         #  TODO(buglloc): maybe file providers?
         if self.is_dump:
@@ -117,9 +123,9 @@ def _resolve_include(self, args, parent):
             LOG.debug("Includes are disallowed, skip: {0}".format(pattern))
             return
 
-        return self._resolve_file_include(pattern=pattern, parent=parent)
+        return self._resolve_file_include(pattern=pattern, parent=parent, path_info)
 
-    def _resolve_file_include(self, pattern, parent):
+    def _resolve_file_include(self, pattern, parent, path_info):
         path = os.path.join(self.cwd, pattern)
         exists = False
         for file_path in glob.iglob(path):
@@ -140,7 +146,7 @@ def _resolve_dump_include(self, pattern, parent):
                 founded = True
                 include = block.IncludeBlock("include", [file_path])
                 parent.append(include)
-                self.parse_block(parsed, include)
+                self.parse_block(parsed, include, file_path)
 
         if not founded:
             LOG.warning("File not found: {0}".format(path))