Port command module over to new common code. Notice that this has to subclass AnsibleModule -- this should be the only

one that has to do that.

library/command

@@ -16,12 +16,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-try:
-    import json
-except ImportError:
-    import simplejson as json
 
 import subprocess
 import sys
@@ -29,79 +23,83 @@ import datetime
 import traceback
 import shlex
 import os
-import syslog
 
-argfile = sys.argv[1]
+def main():
-args = open(argfile, 'r').read()
-syslog.openlog('ansible-%s' % os.path.basename(__file__))
-syslog.syslog(syslog.LOG_NOTICE, 'Invoked with %s' % args)
 
-shell = False
+    # the command module is the one ansible module that does not take key=value args
+    # hence don't copy this one if you are looking to build others!
+    module = CommandModule(argument_spec=dict())
 
-if args.find("#USE_SHELL") != -1:
+    shell = module.params['shell']
-   args = args.replace("#USE_SHELL", "")
+    args  = module.params['args']
-   shell = True
 
-check_args = shlex.split(args)
+    if not shell:
-for x in check_args:
+        args = shlex.split(args)
-   if x.startswith("creates="):
+    startd = datetime.datetime.now()
-       # do not run the command if the line contains creates=filename
-       # and the filename already exists.  This allows idempotence 
-       # of command executions.
-       (k,v) = x.split("=",1)
-       if os.path.exists(v):
-           print json.dumps({
-               "cmd"     : args,
-               "stdout"  : "skipped, since %s exists" % v,
-               "skipped" : True,
-               "changed" : False,
-               "stderr"  : "",
-               "rc"      : 0,
-           })
-           sys.exit(0)
-       args = args.replace(x,'')
 
+    try:
+        cmd = subprocess.Popen(args, shell=shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, err = cmd.communicate()
+    except (OSError, IOError), e:
+        module.fail_json(cmd=args, msg=str(e))
+    except:
+        module.fail_json(msg=traceback.format_exc())
 
-if not shell:
+    endd = datetime.datetime.now()
-    args = shlex.split(args)
+    delta = endd - startd
 
-startd = datetime.datetime.now()
+    if out is None:
+       out = ''
+    if err is None:
+       err = ''
 
-try:
+    module.exit_json(
-    cmd = subprocess.Popen(args, shell=shell, 
+        cmd     = args,
-        stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout  = out.strip(),
-    out, err = cmd.communicate()
+        stderr  = err.strip(),
-except (OSError, IOError), e:
+        rc      = cmd.returncode,
-    print json.dumps({
+        start   = str(startd),
-        "cmd"    : args,
+        end     = str(endd),
-        "failed" : 1,
+        delta   = str(delta),
-        "msg"    : str(e),
+        changed = True
-        })
+    )
-    sys.exit(1)
-except:
-    print json.dumps({
-        "failed" : 1,
-        "msg" : traceback.format_exc()
-    })   
-    sys.exit(1)
 
-endd = datetime.datetime.now()
+# include magic from lib/ansible/module_common.py
-delta = endd - startd
+#<<INCLUDE_ANSIBLE_MODULE_COMMON>>
 
-if out is None:
+# only the command module should ever need to do this
-   out = ''
+# everything else should be simple key=value
-if err is None:
-   err = ''
 
-result = {
+class CommandModule(AnsibleModule):
-   "cmd"     : args,
-   "stdout"  : out.strip(),
-   "stderr"  : err.strip(),
-   "rc"      : cmd.returncode,
-   "start"   : str(startd),
-   "end"     : str(endd),
-   "delta"   : str(delta),
-   "changed" : True
-}
 
-print json.dumps(result)
+    def _load_params(self):
+        ''' read the input and return a dictionary and the arguments string '''
+        args = base64.b64decode(MODULE_ARGS)
+        items   = shlex.split(args)
+        params = {}
+        params['shell'] = False
+        if args.find("#USE_SHELL") != -1:
+             args = args.replace("#USE_SHELL", "")
+             params['shell'] = True
+
+        check_args = shlex.split(args)
+        for x in check_args:
+            if x.startswith("creates="):
+                # do not run the command if the line contains creates=filename
+                # and the filename already exists.  This allows idempotence
+                # of command executions.
+                (k,v) = x.split("=",1)
+                if os.path.exists(v):
+                    self.exit_json(
+                        cmd=args,
+                        stdout="skipped, since %s exists" % v,
+                        skipped=True,
+                        changed=False,
+                        stderr=False,
+                        rc=0
+                    )
+                args = args.replace(x,'')
+        params['args'] = args
+        return (params, args)
+
+main()