Fix PEP8 and lint issues in Xen code.

sesearch

@@ -54,7 +54,7 @@ rtypes.add_argument("--type_change", action="append_const",
 rtypes.add_argument("--type_member", action="append_const",
                     const="type_member", dest="tertypes",
                     help="Search type_member rules.")
-rtypes.add_argument( "--allowx", action="append_const",
+rtypes.add_argument("--allowx", action="append_const",
                     const="allowx", dest="tertypes",
                     help="Search allowx rules.")
 rtypes.add_argument("--auditallowx", action="append_const",

setools/devicetreeconquery.py

@@ -21,6 +21,7 @@ import logging
 from . import contextquery
 from .policyrep.xencontext import dev_path
 
+
 class DevicetreeconQuery(contextquery.ContextQuery):
 
     """
@@ -57,7 +58,6 @@ class DevicetreeconQuery(contextquery.ContextQuery):
 
     _path = None
 
-
     @property
     def path(self):
         return self._path
@@ -95,4 +95,5 @@ class DevicetreeconQuery(contextquery.ContextQuery):
 
             if not self._match_context(devicetreecon.context):
                 continue
+
             yield devicetreecon

setools/iomemconquery.py

@@ -122,4 +122,5 @@ class IomemconQuery(contextquery.ContextQuery):
 
             if not self._match_context(iomemcon.context):
                 continue
+
             yield iomemcon

setools/ioportconquery.py

@@ -119,6 +119,8 @@ class IoportconQuery(contextquery.ContextQuery):
                     self.ports_superset,
                     self.ports_proper):
                 continue
+
             if not self._match_context(ioportcon.context):
                 continue
+
             yield ioportcon

setools/pcideviceconquery.py

@@ -21,6 +21,7 @@ import logging
 from . import contextquery
 from .policyrep.xencontext import device_id
 
+
 class PcideviceconQuery(contextquery.ContextQuery):
 
     """
@@ -57,7 +58,6 @@ class PcideviceconQuery(contextquery.ContextQuery):
 
     _device = None
 
-
     @property
     def device(self):
         return self._device
@@ -95,4 +95,5 @@ class PcideviceconQuery(contextquery.ContextQuery):
 
             if not self._match_context(pcidevicecon.context):
                 continue
+
             yield pcidevicecon

setools/pirqconquery.py

@@ -21,6 +21,7 @@ import logging
 from . import contextquery
 from .policyrep.xencontext import pirq
 
+
 class PirqconQuery(contextquery.ContextQuery):
 
     """
@@ -57,7 +58,6 @@ class PirqconQuery(contextquery.ContextQuery):
 
     _irq = None
 
-
     @property
     def irq(self):
         return self._irq
@@ -95,4 +95,5 @@ class PirqconQuery(contextquery.ContextQuery):
 
             if not self._match_context(pirqcon.context):
                 continue
+
             yield pirqcon

setools/policyrep/__init__.py

@@ -65,6 +65,9 @@ from . import fscontext
 from . import initsid
 from . import netcontext
 
+# Xen
+from . import xencontext
+
 # Classes useful for policyrep users:
 from . import exception
 from .netcontext import PortconProtocol, port_range
@@ -659,7 +662,9 @@ class SELinuxPolicy(object):
         for port in self.policy.portcon_iter():
             yield netcontext.portcon_factory(self.policy, port)
 
-    ### Start XEN statements
+    #
+    # Xen labeling statements
+    #
     def iomemcons(self):
         """Generator which yields all iomemcon statements."""
         for mem_addr in self.policy.iomemcon_iter():
@@ -684,4 +689,3 @@ class SELinuxPolicy(object):
         """Generator which yields all devicetreecon statements."""
         for path in self.policy.devicetreecon_iter():
             yield xencontext.devicetreecon_factory(self.policy, path)
-    ### End XEN statements

setools/policyrep/xencontext.py

@@ -28,6 +28,7 @@ device_id = namedtuple("device_id", ["low"])
 pirq = namedtuple("irq", ["low"])
 dev_path = namedtuple("dev_path", ["path"])
 
+
 def iomemcon_factory(policy, name):
     """Factory function for creating iomemcon objects."""
 
@@ -114,6 +115,7 @@ class Iomemcon(XenContext):
         high = self.qpol_symbol.high_addr(self.policy)
         return addr_range(low, high)
 
+
 class Ioportcon(XenContext):
 
     """A ioportcon statement."""
@@ -140,6 +142,7 @@ class Ioportcon(XenContext):
         high = self.qpol_symbol.high_port(self.policy)
         return port_range(low, high)
 
+
 class Pcidevicecon(XenContext):
 
     """A pcidevicecon statement."""
@@ -160,6 +163,7 @@ class Pcidevicecon(XenContext):
         device_id = self.qpol_symbol.device(self.policy)
         return device_id
 
+
 class Pirqcon(XenContext):
 
     """A pirqcon statement."""
@@ -180,6 +184,7 @@ class Pirqcon(XenContext):
         pirq = self.qpol_symbol.irq(self.policy)
         return pirq
 
+
 class Devicetreecon(XenContext):
 
     """A devicetreecon statement."""

tests/devicetreeconquery.py

@@ -157,50 +157,56 @@ class DevicetreeconQueryTest(unittest.TestCase):
 
     def test_044_range_proper_subset2(self):
         """Devicetreecon query with context range proper subset match (equal)"""
-        q = DevicetreeconQuery(self.p, range_="s4:c1 - s4:c1.c3", range_subset=True, range_proper=True)
+        q = DevicetreeconQuery(self.p,
+                               range_="s4:c1 - s4:c1.c3", range_subset=True, range_proper=True)
 
         path = sorted(p.path for p in q.results())
         self.assertListEqual([], path)
 
     def test_044_range_proper_subset3(self):
         """Devicetreecon query with context range proper subset match (equal low only)"""
-        q = DevicetreeconQuery(self.p, range_="s4:c1 - s4:c1.c2", range_subset=True, range_proper=True)
+        q = DevicetreeconQuery(self.p,
+                               range_="s4:c1 - s4:c1.c2", range_subset=True, range_proper=True)
 
         path = sorted(p.path for p in q.results())
         self.assertListEqual([("/dev/tree44")], path)
 
     def test_044_range_proper_subset4(self):
         """Devicetreecon query with context range proper subset match (equal high only)"""
-        q = DevicetreeconQuery(self.p, range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
+        q = DevicetreeconQuery(self.p,
+                               range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
 
         path = sorted(p.path for p in q.results())
         self.assertListEqual([("/dev/tree44")], path)
 
     def test_045_range_proper_superset1(self):
         """Devicetreecon query with context range proper superset match"""
-        q = DevicetreeconQuery(self.p, range_="s5 - s5:c0.c4", range_superset=True, range_proper=True)
+        q = DevicetreeconQuery(self.p,
+                               range_="s5 - s5:c0.c4", range_superset=True, range_proper=True)
 
         path = sorted(p.path for p in q.results())
         self.assertListEqual([("/dev/tree45")], path)
 
     def test_045_range_proper_superset2(self):
         """Devicetreecon query with context range proper superset match (equal)"""
-        q = DevicetreeconQuery(self.p, range_="s5:c1 - s5:c1.c3", range_superset=True, range_proper=True)
+        q = DevicetreeconQuery(self.p,
+                               range_="s5:c1 - s5:c1.c3", range_superset=True, range_proper=True)
 
         path = sorted(p.path for p in q.results())
         self.assertListEqual([], path)
 
     def test_045_range_proper_superset3(self):
         """Devicetreecon query with context range proper superset match (equal low)"""
-        q = DevicetreeconQuery(self.p, range_="s5:c1 - s5:c1.c4", range_superset=True, range_proper=True)
+        q = DevicetreeconQuery(self.p,
+                               range_="s5:c1 - s5:c1.c4", range_superset=True, range_proper=True)
 
         path = sorted(p.path for p in q.results())
         self.assertListEqual([("/dev/tree45")], path)
 
     def test_045_range_proper_superset4(self):
         """Devicetreecon query with context range proper superset match (equal high)"""
-        q = DevicetreeconQuery(self.p, range_="s5 - s5:c1.c3", range_superset=True, range_proper=True)
+        q = DevicetreeconQuery(self.p,
+                               range_="s5 - s5:c1.c3", range_superset=True, range_proper=True)
 
         path = sorted(p.path for p in q.results())
         self.assertListEqual([("/dev/tree45")], path)
-

tests/iomemconquery.py

@@ -171,7 +171,8 @@ class IomemconQueryTest(unittest.TestCase):
 
     def test_044_range_proper_subset4(self):
         """Iomemcon query with context range proper subset match (equal high only)"""
-        q = IomemconQuery(self.p, range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
+        q = IomemconQuery(self.p,
+                          range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
 
         mem_addr = sorted(p.mem_addr for p in q.results())
         self.assertListEqual([(44, 44)], mem_addr)

tests/ioportconquery.py

@@ -171,7 +171,8 @@ class IoportconQueryTest(unittest.TestCase):
 
     def test_044_range_proper_subset4(self):
         """Portcon query with context range proper subset match (equal high only)"""
-        q = IoportconQuery(self.p, range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
+        q = IoportconQuery(self.p,
+                           range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
 
         ports = sorted(p.ports for p in q.results())
         self.assertListEqual([(44, 44)], ports)
@@ -185,14 +186,16 @@ class IoportconQueryTest(unittest.TestCase):
 
     def test_045_range_proper_superset2(self):
         """Portcon query with context range proper superset match (equal)"""
-        q = IoportconQuery(self.p, range_="s5:c1 - s5:c1.c3", range_superset=True, range_proper=True)
+        q = IoportconQuery(self.p,
+                           range_="s5:c1 - s5:c1.c3", range_superset=True, range_proper=True)
 
         ports = sorted(p.ports for p in q.results())
         self.assertListEqual([], ports)
 
     def test_045_range_proper_superset3(self):
         """Portcon query with context range proper superset match (equal low)"""
-        q = IoportconQuery(self.p, range_="s5:c1 - s5:c1.c4", range_superset=True, range_proper=True)
+        q = IoportconQuery(self.p,
+                           range_="s5:c1 - s5:c1.c4", range_superset=True, range_proper=True)
 
         ports = sorted(p.ports for p in q.results())
         self.assertListEqual([(45, 45)], ports)

tests/pcideviceconquery.py

@@ -157,50 +157,56 @@ class PcideviceconQueryTest(unittest.TestCase):
 
     def test_044_range_proper_subset2(self):
         """Pcidevicecon query with context range proper subset match (equal)"""
-        q = PcideviceconQuery(self.p, range_="s4:c1 - s4:c1.c3", range_subset=True, range_proper=True)
+        q = PcideviceconQuery(self.p,
+                              range_="s4:c1 - s4:c1.c3", range_subset=True, range_proper=True)
 
         device = sorted(p.device for p in q.results())
         self.assertListEqual([], device)
 
     def test_044_range_proper_subset3(self):
         """Pcidevicecon query with context range proper subset match (equal low only)"""
-        q = PcideviceconQuery(self.p, range_="s4:c1 - s4:c1.c2", range_subset=True, range_proper=True)
+        q = PcideviceconQuery(self.p,
+                              range_="s4:c1 - s4:c1.c2", range_subset=True, range_proper=True)
 
         device = sorted(p.device for p in q.results())
         self.assertListEqual([(44)], device)
 
     def test_044_range_proper_subset4(self):
         """Pcidevicecon query with context range proper subset match (equal high only)"""
-        q = PcideviceconQuery(self.p, range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
+        q = PcideviceconQuery(self.p,
+                              range_="s4:c1,c2 - s4:c1.c3", range_subset=True, range_proper=True)
 
         device = sorted(p.device for p in q.results())
         self.assertListEqual([(44)], device)
 
     def test_045_range_proper_superset1(self):
         """Pcidevicecon query with context range proper superset match"""
-        q = PcideviceconQuery(self.p, range_="s5 - s5:c0.c4", range_superset=True, range_proper=True)
+        q = PcideviceconQuery(self.p,
+                              range_="s5 - s5:c0.c4", range_superset=True, range_proper=True)
 
         device = sorted(p.device for p in q.results())
         self.assertListEqual([(45)], device)
 
     def test_045_range_proper_superset2(self):
         """Pcidevicecon query with context range proper superset match (equal)"""
-        q = PcideviceconQuery(self.p, range_="s5:c1 - s5:c1.c3", range_superset=True, range_proper=True)
+        q = PcideviceconQuery(self.p,
+                              range_="s5:c1 - s5:c1.c3", range_superset=True, range_proper=True)
 
         device = sorted(p.device for p in q.results())
         self.assertListEqual([], device)
 
     def test_045_range_proper_superset3(self):
         """Pcidevicecon query with context range proper superset match (equal low)"""
-        q = PcideviceconQuery(self.p, range_="s5:c1 - s5:c1.c4", range_superset=True, range_proper=True)
+        q = PcideviceconQuery(self.p,
+                              range_="s5:c1 - s5:c1.c4", range_superset=True, range_proper=True)
 
         device = sorted(p.device for p in q.results())
         self.assertListEqual([(45)], device)
 
     def test_045_range_proper_superset4(self):
         """Pcidevicecon query with context range proper superset match (equal high)"""
-        q = PcideviceconQuery(self.p, range_="s5 - s5:c1.c3", range_superset=True, range_proper=True)
+        q = PcideviceconQuery(self.p,
+                              range_="s5 - s5:c1.c3", range_superset=True, range_proper=True)
 
         device = sorted(p.device for p in q.results())
         self.assertListEqual([(45)], device)
-

tests/pirqconquery.py

@@ -203,4 +203,3 @@ class PirqconQueryTest(unittest.TestCase):
 
         irq = sorted(p.irq for p in q.results())
         self.assertListEqual([(45)], irq)
-