add support to junos_command module for netconf transport

This adds support for using netconf to the junos_command option and removes
the use of cli as a transport

network/junos/junos_command.py

@@ -20,32 +20,40 @@ DOCUMENTATION = """
 ---
 module: junos_command
 version_added: "2.1"
-author: "Peter sprygada (@privateip)"
+author: "Peter Sprygada (@privateip)"
-short_description: Execute arbitrary commands on Juniper JUNOS devices
+short_description: Execute arbitrary commands on a remote device running Junos
 description:
-  - Netork devices running Juniper JUNOS can execute a variety of commands
+  - Network devices running the Junos operating system provide a command
-    to display both configuration and state data.  This module will take
+    driven interface both over CLI and RPC.  This module provides an
-    an ordered set of commands and execute them in JUNOS and return the
+    interface to execute commands using these functions and return the
-    command results.  It also supports adding conditionals the
+    results to the Ansible playbook.  In addition, the M(junos_command)
-    argument set to force the module to meet a set of criteria before
+    module can specify a set of conditionals to be evaluated against the
-    proceeding.
+    returned output, only returning control to the playbook once the
+    entire set of conditionals has been met.
 extends_documentation_fragment: junos
 options:
   commands:
     description:
-      - The commands to send to the remote JUNOS device over the
+      - An ordered set of CLI commands to be executed on the remote
-        configured provider.  The resulting output from the command
+        device.  The output from the commands is then returned to
-        is returned.  If the I(waitfor) argument is provided, the
+        the playbook in the task results.
-        module is not returned until the condition is satisfied or
+    required: false
-        the number of retires as expired.
+    default: null
-    required: true
+  rpcs:
+    description:
+      - The O(rpcs) argument accepts a list of RPCs to be executed
+        over a netconf session and the results from the RPC execution
+        is return to the playbook via the modules results dictionary.
+    required: false
+    default: null
   waitfor:
     description:
       - Specifies what to evaluate from the output of the command
         and what conditionals to apply.  This argument will cause
-        the task to wait for a particular conditional to be true
+        the task to wait for a particular conditional or set of
-        before moving forward.   If the conditional is not true
+        considitonals to be true before moving forward.   If the
-        by the configured retries, the task fails.  See examples.
+        conditional is not true by the configured retries, the
+        task fails.  See examples.
     required: false
     default: null
   retries:
@@ -64,6 +72,19 @@ options:
         trying the command again.
     required: false
     default: 1
+  format:
+    description:
+      - Configures the encoding scheme to use when serializing output
+        from the device.  This handles how to properly understand the
+        output and apply the conditionals path to the result set.
+    required: false
+    default: 'xml'
+    choices: ['xml', 'text']
+requirements:
+  - junos-eznc
+notes:
+  - This module requires the netconf system service be enabled on
+    the remote device being managed
 """
 
 EXAMPLES = """
@@ -78,10 +99,15 @@ EXAMPLES = """
   junos_command:
     commands:
       - show version
-      - show interfaces fxp0 | display json
+      - show interfaces fxp0
     waitfor:
-      - "result[1].interface-information[0].physical-interface[0].name[0].data
+      - "result[1].interface-information.physical-interface.name eq fxp0"
-        eq fxp0"
+
+- name: collect interface information using rpc
+  junos_command:
+    rpcs:
+      - "get_interface_information interface=em0 media=True"
+      - "get_interface_information interface=fxp0 media=True"
 """
 
 RETURN = """
@@ -97,137 +123,93 @@ stdout_lines:
   type: list
   sample: [['...', '...'], ['...', '...']]
 
+xml:
+  description: The raw XML reply from the device
+  returned: when format is xml
+  type: list
+  sample: [['...', '...'], ['...', '...']]
+
 failed_conditionals:
   description: the conditionals that failed
   retured: failed
   type: list
   sample: ['...', '...']
 """
-
-import time
 import shlex
-import re
-import json
-import itertools
-
-INDEX_RE = re.compile(r'(\[\d+\])')
-
-class Conditional(object):
-
-    OPERATORS = {
-        'eq': ['eq', '=='],
-        'neq': ['neq', 'ne', '!='],
-        'gt': ['gt', '>'],
-        'ge': ['ge', '>='],
-        'lt': ['lt', '<'],
-        'le': ['le', '<='],
-        'contains': ['contains', 'in']
-    }
-
-    def __init__(self, conditional):
-        self.raw = conditional
-
-        key, op, val = shlex.split(conditional)
-        self.key = key
-        self.func = self.func(op)
-        self.value = self._cast_value(val)
-
-    def __call__(self, data):
-        try:
-            value = self.get_value(dict(result=data))
-            return self.func(value)
-        except Exception:
-            raise
-
-    def _cast_value(self, value):
-        if value in BOOLEANS_TRUE:
-            return True
-        elif value in BOOLEANS_FALSE:
-            return False
-        elif re.match(r'^\d+\.d+$', value):
-            return float(value)
-        elif re.match(r'^\d+$', value):
-            return int(value)
-        else:
-            return unicode(value)
-
-    def func(self, oper):
-        for func, operators in self.OPERATORS.items():
-            if oper in operators:
-                return getattr(self, func)
-        raise AttributeError('unknown operator: %s' % oper)
-
-    def get_value(self, result):
-        for key in self.key.split('.'):
-            match = re.match(r'^(.+)\[(\d+)\]', key)
-            if match:
-                key, index = match.groups()
-                result = result[key][int(index)]
-            else:
-                result = result.get(key)
-        return result
-
-    def number(self, value):
-        if '.' in str(value):
-            return float(value)
-        else:
-            return int(value)
-
-    def eq(self, value):
-        return value == self.value
 
-    def neq(self, value):
+def split(value):
-        return value != self.value
+    lex = shlex.shlex(value)
-
+    lex.quotes = '"'
-    def gt(self, value):
+    lex.whitespace_split = True
-        return self.number(value) > self.value
+    lex.commenters = ''
-
+    return list(lex)
-    def ge(self, value):
+
-        return self.number(value) >= self.value
+def rpc_args(args):
-
+    kwargs = dict()
-    def lt(self, value):
+    args = split(args)
-        return self.number(value) < self.value
+    name = args.pop(0)
-
+    for arg in args:
-    def le(self, value):
+        key, value = arg.split('=')
-        return self.number(value) <= self.value
+        if str(value).upper() in ['TRUE', 'FALSE']:
-
+            kwargs[key] = bool(value)
-    def contains(self, value):
+        elif re.match(r'\d+', value):
-        return self.value in value
+            kwargs[key] = int(value)
-
+        else:
-def parse_response(module, responses):
+            kwargs[key] = str(value)
-    commands = module.params['commands']
+    return (name, kwargs)
-    result = dict(stdout_json=list(), stdout=list(), stdout_lines=list())
+
-    for cmd, resp in itertools.izip(commands, responses):
+def parse_rpcs(rpcs):
-        result['stdout'].append(resp)
+    parsed = list()
-        if cmd.endswith('json'):
+    for rpc in (rpcs or list()):
-            result['stdout_json'].append(module.jsonify(resp))
+        parsed.append(rpc_args(rpc))
+    return parsed
+
+def run_rpcs(module, items, format):
+    response = list()
+    for name, kwargs in items:
+        kwargs['format'] = format
+        result = module.connection.rpc(name, **kwargs)
+        if format == 'text':
+            response.append(result.text)
         else:
-            result['stdout_lines'].append(resp.split('\n'))
+            response.append(result)
-    return result
+    return response
 
-def to_lines(stdout):
+def iterlines(stdout):
     for item in stdout:
         if isinstance(item, basestring):
             item = str(item).split('\n')
         yield item
 
 def main():
+    """main entry point for Ansible module
+    """
+
     spec = dict(
         commands=dict(type='list'),
+        rpcs=dict(type='list'),
+        format=dict(default='xml', choices=['text', 'xml']),
         waitfor=dict(type='list'),
         retries=dict(default=10, type='int'),
-        interval=dict(default=1, type='int')
+        interval=dict(default=1, type='int'),
+        transport=dict(default='netconf', choices=['netconf'])
     )
 
+    mutually_exclusive = [('commands', 'rpcs')]
+
     module = get_module(argument_spec=spec,
+                        mutually_exclusive=mutually_exclusive,
                         supports_check_mode=True)
 
 
     commands = module.params['commands']
+    rpcs = parse_rpcs(module.params['rpcs'])
 
+    encoding = module.params['format']
     retries = module.params['retries']
     interval = module.params['interval']
 
+
     try:
         queue = set()
         for entry in (module.params['waitfor'] or list()):
@@ -238,15 +220,18 @@ def main():
     result = dict(changed=False)
 
     while retries > 0:
-        try:
+        if commands:
-            response = module.execute(commands)
+            response = module.run_commands(commands, format=encoding)
-            result['stdout'] = response
+        else:
-        except ShellError:
+            response = run_rpcs(module, rpcs, format=encoding)
-            module.fail_json(msg='failed to run commands')
 
-        for index, cmd in enumerate(commands):
+        result['stdout'] = response
-            if cmd.endswith('json'):
+        xmlout = list()
-                response[index] = json.loads(response[index])
+
+        for index in range(0, len(response)):
+            if encoding == 'xml':
+                xmlout.append(xml_to_string(response[index]))
+                response[index] = xml_to_json(response[index])
 
         for item in list(queue):
             if item(response):
@@ -261,13 +246,17 @@ def main():
         failed_conditions = [item.raw for item in queue]
         module.fail_json(msg='timeout waiting for value', failed_conditions=failed_conditions)
 
-    result['stdout_lines'] = list(to_lines(result['stdout']))
+    if xmlout:
-    return module.exit_json(**result)
+        result['xml'] = xmlout
+
+    result['stdout_lines'] = list(iterlines(result['stdout']))
+    module.exit_json(**result)
 
 
 from ansible.module_utils.basic import *
-from ansible.module_utils.shell import *
+from ansible.module_utils.netcfg import *
 from ansible.module_utils.junos import *
+
 if __name__ == '__main__':
-        main()
+    main()