General code cleanup

Author: Shakeel Mohamed

splunklib/modularinput/argument.py

@@ -41,12 +41,13 @@ class Argument(object):
             )
     """
 
-    # Constant values, do not change
+    # Constant values, do not change.
+    # These should be used for setting the value of an Argument object's data_type field.
     data_type_boolean = "BOOLEAN"
     data_type_number = "NUMBER"
     data_type_string = "STRING"
 
-    def __init__(self, name, description=None, validation=None, \
+    def __init__(self, name, description=None, validation=None,
                  data_type=data_type_string, required_on_edit=False, required_on_create=False):
         """
         :param name: string, identifier for this argument in Splunk

splunklib/modularinput/event.py

@@ -22,7 +22,7 @@ class Event(object):
 
     To write an input to a stream, call the write_to function, passing in a stream.
     """
-    def __init__(self, data=None, stanza=None, time=None, host=None, index=None, source=None,\
+    def __init__(self, data=None, stanza=None, time=None, host=None, index=None, source=None,
                  sourceType=None, done=True, unbroken=True):
         """There are no required parameters for constructing an Event
 
@@ -71,7 +71,8 @@ def __init__(self, data=None, stanza=None, time=None, host=None, index=None, sou
     def write_to(self, stream):
         """Write an XML representation of self, an Event object, to the given stream
 
-        The Event object will only be written if its data field is defined
+        The Event object will only be written if its data field is defined,
+        else a ValueError is raised.
 
         :param stream: stream to write XML to
         """
@@ -96,10 +97,10 @@ def write_to(self, stream):
             ("data", self.data)
         ]
         for node, value in subelements:
-            if value:
+            if value is not None:
                 ET.SubElement(event, node).text = value
 
-        if self.done:
+        if self.done is not None:
             ET.SubElement(event, "done")
 
         stream.write(ET.tostring(event))

splunklib/modularinput/event_writer.py

@@ -12,7 +12,7 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-from splunklib.modularinput.event import Event, ET
+from splunklib.modularinput.event import ET
 import sys
 
 try:
@@ -48,9 +48,6 @@ def __init__(self, output = sys.stdout, error = sys.stderr):
 
     def write_event(self, event):
         """Write an Event object to Splunk.
-        If the opening <stream> tag hasn't been written,
-        write it & set header_written to True
-        Then, write the event.
 
         :param event: an Event object
         """

splunklib/modularinput/input_definition.py

@@ -29,13 +29,13 @@ def __init__ (self):
         self.metadata = {}
         self.inputs = {}
 
-
     def __eq__(self, other):
         if not isinstance(other, InputDefinition):
             return False
         return self.metadata == other.metadata and self.inputs == other.inputs
 
-def parse_input_definition(stream):
+    @staticmethod
+    def parse_input_definition(stream):
         """Parse a stream containing XML into an InputDefinition.
 
         :param stream: stream containing XML to parse

splunklib/modularinput/scheme.py

@@ -27,6 +27,7 @@ class Scheme(object):
     """
 
     # Constant values, do not change
+    # These should be used for setting the value of a Scheme object's streaming_mode field.
     streaming_mode_simple = "SIMPLE"
     streaming_mode_xml = "XML"
 
@@ -50,7 +51,7 @@ def add_argument(self, arg):
         """
         self.arguments.append(arg)
 
-    def to_XML(self):
+    def to_xml(self):
         """Creates an ET.Element representing self, then returns it
 
         :return root, an ET.Element representing this scheme
@@ -63,10 +64,14 @@ def to_XML(self):
         if self.description is not None:
             ET.SubElement(root, "description").text = self.description
 
-        # add other subelements
-        ET.SubElement(root, "use_external_validation").text = str(self.use_external_validation).lower()
-        ET.SubElement(root, "use_single_instance").text = str(self.use_single_instance).lower()
-        ET.SubElement(root, "streaming_mode").text = self.streaming_mode.lower()
+        # add other subelements; represented by (tag, text)
+        subelements = [
+            ("use_external_validation", str(self.use_external_validation).lower()),
+            ("use_single_instance", str(self.use_single_instance).lower()),
+            ("streaming_mode", self.streaming_mode.lower())
+        ]
+        for name, value in subelements:
+            ET.SubElement(root, name).text = value
 
         endpoint = ET.SubElement(root, "endpoint")
 

splunklib/modularinput/script.py

@@ -13,11 +13,10 @@
 # under the License.
 
 from abc import ABCMeta, abstractmethod
-import sys
-from splunklib.modularinput.input_definition import InputDefinition, parse_input_definition
-from splunklib.modularinput.validation_definition import ValidationDefinition, parse_validation_definition
+from splunklib.modularinput.input_definition import InputDefinition
+from splunklib.modularinput.validation_definition import ValidationDefinition
 from splunklib.modularinput.event_writer import EventWriter
-from splunklib.modularinput.scheme import Scheme
+import sys
 
 try:
     import xml.etree.cElementTree as ET
@@ -28,12 +27,11 @@
 class Script(object):
     """An abstract base class for implementing modular inputs.
 
-    Subclasses should override getScheme, StreamEvents,
-    and optional configureValidator if the modular Input uses
+    Subclasses should override get_scheme, stream_events,
+    and optional validate_input if the modular Input uses
     external validation.
 
     The important function is run, which is used to run modular inputs
-
     """
     __metaclass__ = ABCMeta
 
@@ -58,7 +56,7 @@ def run_script(self, args, event_writer, input_stream):
             if len(args) == 0:
                 # This script is running as an input. Input definitions will be passed on stdin
                 # as XML, and the script will write events on stdout and log entries on stderr.
-                input_definition = parse_input_definition(input_stream)
+                input_definition = InputDefinition.parse_input_definition(input_stream)
                 self.stream_events(input_definition, event_writer)
                 event_writer.close()
                 return 0
@@ -71,11 +69,11 @@ def run_script(self, args, event_writer, input_stream):
                     event_writer.log(EventWriter.FATAL, "Modular input script returned a null scheme.")
                     return 1
                 else:
-                    event_writer.write_xml_document(scheme.to_XML())
+                    event_writer.write_xml_document(scheme.to_xml())
                     return 0
 
             elif args[0].lower() == "--validate-arguments":
-                validation_definition = parse_validation_definition(input_stream)
+                validation_definition = ValidationDefinition.parse_validation_definition(input_stream)
                 try:
                     self.validate_input(validation_definition)
                     return 0

splunklib/modularinput/utils.py

@@ -41,21 +41,23 @@ def xml_compare(expected, found):
         return False
 
     # compare elements, if there is no text node, return True
-    if (expected.text is None or expected.text.strip() == "") and (found.text is None or found.text.strip() == ""):
+    if (expected.text is None or expected.text.strip() == "") \
+        and (found.text is None or found.text.strip() == ""):
         return True
     else:
-        return expected.tag == found.tag and expected.text == found.text and expected.attrib == found.attrib
+        return expected.tag == found.tag and expected.text == found.text \
+            and expected.attrib == found.attrib
 
-def parse_parameters(paramNode):
-    if paramNode.tag == "param":
-        return paramNode.text
-    elif paramNode.tag == "param_list":
+def parse_parameters(param_node):
+    if param_node.tag == "param":
+        return param_node.text
+    elif param_node.tag == "param_list":
         parameters = []
-        for mvp in paramNode:
+        for mvp in param_node:
             parameters.append(mvp.text)
         return parameters
     else:
-        raise ValueError("Invalid configuration scheme, %s tag unexpected." % paramNode.tag)
+        raise ValueError("Invalid configuration scheme, %s tag unexpected." % param_node.tag)
 
 def parse_xml_data(parent_node, child_node_tag):
     data = {}

splunklib/modularinput/validation_definition.py

@@ -35,43 +35,44 @@ def __eq__(self, other):
             return False
         return self.metadata == other.metadata and self.parameters == other.parameters
 
-def parse_validation_definition(stream):
-    """Creates a ValidationDefinition from a provided stream containing XML.
+    @staticmethod
+    def parse_validation_definition(stream):
+        """Creates a ValidationDefinition from a provided stream containing XML.
 
-    The XML typically will look like
+        The XML typically will look like
 
-    <items>
-        <server_host>myHost</server_host>
-        <server_uri>https://127.0.0.1:8089</server_uri>
-        <session_key>123102983109283019283</session_key>
-        <checkpoint_dir>/opt/splunk/var/lib/splunk/modinputs</checkpoint_dir>
-        <item name="myScheme">
-            <param name="param1">value1</param>
-            <param_list name="param2">
-                <value>value2</value>
-                <value>value3</value>
-                <value>value4</value>
-            </param_list>
-        </item>
-    </items>
+        <items>
+            <server_host>myHost</server_host>
+            <server_uri>https://127.0.0.1:8089</server_uri>
+            <session_key>123102983109283019283</session_key>
+            <checkpoint_dir>/opt/splunk/var/lib/splunk/modinputs</checkpoint_dir>
+            <item name="myScheme">
+                <param name="param1">value1</param>
+                <param_list name="param2">
+                    <value>value2</value>
+                    <value>value3</value>
+                    <value>value4</value>
+                </param_list>
+            </item>
+        </items>
 
-    :param stream: stream containing XML to parse
-    :return definition: a ValidationDefinition object
-    """
+        :param stream: stream containing XML to parse
+        :return definition: a ValidationDefinition object
+        """
 
-    definition = ValidationDefinition()
+        definition = ValidationDefinition()
 
-    # parse XML from the stream, then get the root node
-    root = ET.parse(stream).getroot()
+        # parse XML from the stream, then get the root node
+        root = ET.parse(stream).getroot()
 
-    for node in root:
-        # lone item node
-        if node.tag == "item":
-            # name from item node
-            definition.metadata["name"] = node.get("name")
-            definition.parameters = parse_xml_data(node, "")
-        else:
-            # Store anything else in metadata
-            definition.metadata[node.tag] = node.text
+        for node in root:
+            # lone item node
+            if node.tag == "item":
+                # name from item node
+                definition.metadata["name"] = node.get("name")
+                definition.parameters = parse_xml_data(node, "")
+            else:
+                # Store anything else in metadata
+                definition.metadata[node.tag] = node.text
 
-    return definition
+        return definition

tests/modularinput/test_event.py

@@ -135,7 +135,7 @@ def test_logging_errors_with_event_writer(self):
         self.assertEqual("ERROR Something happened!\n", err.getvalue())
 
     def test_write_xml_is_sane(self):
-        """Check that EventWriter.writeXmlDocument writes sensible
+        """Check that EventWriter.write_xml_document writes sensible
         XML to the output stream."""
         out = StringIO()
         err = StringIO()

tests/modularinput/test_input_definition.py

@@ -15,14 +15,14 @@
 # under the License.
 
 from tests.modularinput.modularinput_testlib import unittest
-from splunklib.modularinput.input_definition import InputDefinition, parse_input_definition
+from splunklib.modularinput.input_definition import InputDefinition
 
 class InputDefinitionTestCase(unittest.TestCase):
 
     def test_parse_inputdef_with_zero_inputs(self):
         """Check parsing of XML that contains only metadata"""
 
-        found = parse_input_definition(open("data/conf_with_0_inputs.xml"))
+        found = InputDefinition.parse_input_definition(open("data/conf_with_0_inputs.xml"))
 
         expectedDefinition = InputDefinition()
         expectedDefinition.metadata = {
@@ -37,7 +37,7 @@ def test_parse_inputdef_with_zero_inputs(self):
     def test_parse_inputdef_with_two_inputs(self):
         """Check parsing of XML that contains 2 inputs"""
 
-        found = parse_input_definition(open("data/conf_with_2_inputs.xml"))
+        found = InputDefinition.parse_input_definition(open("data/conf_with_2_inputs.xml"))
 
         expectedDefinition = InputDefinition()
         expectedDefinition.metadata = {
@@ -67,7 +67,7 @@ def test_attempt_to_parse_malformed_input_definition_will_throw_exception(self):
         """Does malformed XML cause the expected exception."""
 
         with self.assertRaises(ValueError):
-            found = parse_input_definition(open("data/conf_with_invalid_inputs.xml"))
+            found = InputDefinition.parse_input_definition(open("data/conf_with_invalid_inputs.xml"))
 
 if __name__ == "__main__":
     unittest.main()