Restructuring.

lib/ansible/modules/web_infrastructure/apache2_module

@@ -0,0 +1,89 @@
+#!/usr/bin/python
+#coding: utf-8 -*-
+
+# (c) 2013-2014, Christian Berendt <berendt@b1-systems.de>
+#
+# This module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this software.  If not, see <http://www.gnu.org/licenses/>.
+
+DOCUMENTATION = '''
+---
+module: apache2_module
+version_added: 1.6
+short_description: enables/disables a module of the Apache2 webserver
+description:
+   - Enables or disables a specified module of the Apache2 webserver.
+options:
+   name:
+     description:
+        - name of the module to enable/disable
+     required: true
+   state:
+     description:
+        - indicate the desired state of the resource
+     choices: ['present', 'absent']
+     default: present
+
+'''
+
+EXAMPLES = '''
+# enables the Apache2 module "wsgi"
+- apache2_module: state=present name=wsgi
+
+# disables the Apache2 module "wsgi"
+- apache2_module: state=absent name=wsgi
+'''
+
+import re
+
+def _disable_module(module):
+    name = module.params['name']
+    a2dismod_binary = module.get_bin_path("a2dismod")
+    result, stdout, stderr = module.run_command("%s %s" % (a2dismod_binary, name))
+
+    if re.match(r'.*' + name + r' already disabled.*', stdout, re.S):
+        module.exit_json(changed = False, result = "Success")
+    elif result != 0:
+        module.fail_json(msg="Failed to disable module %s: %s" % (name, stdout))
+    else:
+        module.exit_json(changed = True, result = "Disabled")
+
+def _enable_module(module):
+    name = module.params['name']
+    a2enmod_binary = module.get_bin_path("a2enmod")
+    result, stdout, stderr = module.run_command("%s %s" % (a2enmod_binary, name))
+
+    if re.match(r'.*' + name + r' already enabled.*', stdout, re.S):
+        module.exit_json(changed = False, result = "Success")
+    elif result != 0:
+        module.fail_json(msg="Failed to enable module %s: %s" % (name, stdout))
+    else:
+        module.exit_json(changed = True, result = "Enabled")
+
+def main():
+    module = AnsibleModule(
+        argument_spec = dict(
+            name  = dict(required=True),
+            state = dict(default='present', choices=['absent', 'present'])
+        ),
+    )
+
+    if module.params['state'] == 'present':
+        _enable_module(module)
+
+    if module.params['state'] == 'absent':
+        _disable_module(module)
+
+# import module snippets
+from ansible.module_utils.basic import *
+main()

lib/ansible/modules/web_infrastructure/django_manage

@@ -0,0 +1,281 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# (c) 2013, Scott Anderson <scottanderson42@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+DOCUMENTATION = '''
+---
+module: django_manage
+short_description: Manages a Django application.
+description:
+     - Manages a Django application using the I(manage.py) application frontend to I(django-admin). With the I(virtualenv) parameter, all management commands will be executed by the given I(virtualenv) installation.
+version_added: "1.1"
+options:
+  command:
+    choices: [ 'cleanup', 'collectstatic', 'flush', 'loaddata', 'migrate', 'runfcgi', 'syncdb', 'test', 'validate', ]
+    description:
+      - The name of the Django management command to run. Built in commands are cleanup, collectstatic, flush, loaddata, migrate, runfcgi, syncdb, test, and validate. Other commands can be entered, but will fail if they're unknown to Django.
+    required: true
+  app_path:
+    description:
+      - The path to the root of the Django application where B(manage.py) lives.
+    required: true
+  settings:
+    description:
+      - The Python path to the application's settings module, such as 'myapp.settings'.
+    required: false
+  pythonpath:
+    description:
+      - A directory to add to the Python path. Typically used to include the settings module if it is located external to the application directory.
+    required: false
+  virtualenv:
+    description:
+      - An optional path to a I(virtualenv) installation to use while running the manage application.
+    required: false
+  apps:
+    description:
+      - A list of space-delimited apps to target. Used by the 'test' command.
+    required: false
+  cache_table:
+    description:
+      - The name of the table used for database-backed caching. Used by the 'createcachetable' command.
+    required: false
+  database:
+    description:
+      - The database to target. Used by the 'createcachetable', 'flush', 'loaddata', and 'syncdb' commands.
+    required: false
+  failfast:
+    description:
+      - Fail the command immediately if a test fails. Used by the 'test' command.
+    required: false
+    default: "no"
+    choices: [ "yes", "no" ]
+  fixtures:
+    description:
+      - A space-delimited list of fixture file names to load in the database. B(Required) by the 'loaddata' command.
+    required: false
+  skip:
+    description:
+     - Will skip over out-of-order missing migrations, you can only use this parameter with I(migrate)
+    required: false
+    version_added: "1.3"
+  merge:
+    description:
+     - Will run out-of-order or missing migrations as they are not rollback migrations, you can only use this parameter with 'migrate' command
+    required: false
+    version_added: "1.3"
+  link:
+    description:
+     - Will create links to the files instead of copying them, you can only use this parameter with 'collectstatic' command
+    required: false
+    version_added: "1.3"
+notes:
+   - I(virtualenv) (U(http://www.virtualenv.org)) must be installed on the remote host if the virtualenv parameter is specified.
+   - This module will create a virtualenv if the virtualenv parameter is specified and a virtualenv does not already exist at the given location.
+   - This module assumes English error messages for the 'createcachetable' command to detect table existence, unfortunately.
+   - To be able to use the migrate command, you must have south installed and added as an app in your settings
+   - To be able to use the collectstatic command, you must have enabled staticfiles in your settings
+requirements: [ "virtualenv", "django" ]
+author: Scott Anderson
+'''
+
+EXAMPLES = """
+# Run cleanup on the application installed in 'django_dir'.
+- django_manage: command=cleanup app_path={{ django_dir }}
+
+# Load the initial_data fixture into the application
+- django_manage: command=loaddata app_path={{ django_dir }} fixtures={{ initial_data }}
+
+#Run syncdb on the application
+- django_manage: >
+      command=syncdb
+      app_path={{ django_dir }}
+      settings={{ settings_app_name }}
+      pythonpath={{ settings_dir }}
+      virtualenv={{ virtualenv_dir }}
+
+#Run the SmokeTest test case from the main app. Useful for testing deploys.
+- django_manage: command=test app_path=django_dir apps=main.SmokeTest
+"""
+
+
+import os
+
+def _fail(module, cmd, out, err, **kwargs):
+    msg = ''
+    if out:
+        msg += "stdout: %s" % (out, )
+    if err:
+        msg += "\n:stderr: %s" % (err, )
+    module.fail_json(cmd=cmd, msg=msg, **kwargs)
+
+
+def _ensure_virtualenv(module):
+
+    venv_param = module.params['virtualenv']
+    if venv_param is None:
+        return
+
+    vbin = os.path.join(os.path.expanduser(venv_param), 'bin')
+    activate = os.path.join(vbin, 'activate')
+
+    if not os.path.exists(activate):
+        virtualenv = module.get_bin_path('virtualenv', True)
+        vcmd = '%s %s' % (virtualenv, venv_param)
+        vcmd = [virtualenv, venv_param]
+        rc, out_venv, err_venv = module.run_command(vcmd)
+        if rc != 0:
+            _fail(module, vcmd, out_venv, err_venv)
+
+    os.environ["PATH"] = "%s:%s" % (vbin, os.environ["PATH"])
+    os.environ["VIRTUAL_ENV"] = venv_param
+
+def createcachetable_filter_output(line):
+    return "Already exists" not in line
+
+def flush_filter_output(line):
+    return "Installed" in line and "Installed 0 object" not in line
+
+def loaddata_filter_output(line):
+    return "Installed" in line and "Installed 0 object" not in line
+
+def syncdb_filter_output(line):
+    return ("Creating table " in line) or ("Installed" in line and "Installed 0 object" not in line)
+
+def migrate_filter_output(line):
+    return ("Migrating forwards " in line) or ("Installed" in line and "Installed 0 object" not in line)
+
+def main():
+    command_allowed_param_map = dict(
+        cleanup=(),
+        createcachetable=('cache_table', 'database', ),
+        flush=('database', ),
+        loaddata=('database', 'fixtures', ),
+        syncdb=('database', ),
+        test=('failfast', 'testrunner', 'liveserver', 'apps', ),
+        validate=(),
+        migrate=('apps', 'skip', 'merge'),
+        collectstatic=('link', ),
+        )
+
+    command_required_param_map = dict(
+        loaddata=('fixtures', ),
+        createcachetable=('cache_table', ),
+        )
+
+    # forces --noinput on every command that needs it
+    noinput_commands = (
+        'flush',
+        'syncdb',
+        'migrate',
+        'test',
+        'collectstatic',
+        )
+
+    # These params are allowed for certain commands only
+    specific_params = ('apps', 'database', 'failfast', 'fixtures', 'liveserver', 'testrunner')
+
+    # These params are automatically added to the command if present
+    general_params = ('settings', 'pythonpath', 'database',)
+    specific_boolean_params = ('failfast', 'skip', 'merge', 'link')
+    end_of_command_params = ('apps', 'cache_table', 'fixtures')
+
+    module = AnsibleModule(
+        argument_spec=dict(
+            command     = dict(default=None, required=True),
+            app_path    = dict(default=None, required=True),
+            settings    = dict(default=None, required=False),
+            pythonpath  = dict(default=None, required=False, aliases=['python_path']),
+            virtualenv  = dict(default=None, required=False, aliases=['virtual_env']),
+
+            apps        = dict(default=None, required=False),
+            cache_table = dict(default=None, required=False),
+            database    = dict(default=None, required=False),
+            failfast    = dict(default='no', required=False, type='bool', aliases=['fail_fast']),
+            fixtures    = dict(default=None, required=False),
+            liveserver  = dict(default=None, required=False, aliases=['live_server']),
+            testrunner  = dict(default=None, required=False, aliases=['test_runner']),
+            skip        = dict(default=None, required=False, type='bool'),
+            merge       = dict(default=None, required=False, type='bool'),
+            link        = dict(default=None, required=False, type='bool'),
+        ),
+    )
+
+    command = module.params['command']
+    app_path = module.params['app_path']
+    virtualenv = module.params['virtualenv']
+
+    for param in specific_params:
+        value = module.params[param]
+        if param in specific_boolean_params:
+            value = module.boolean(value)
+        if value and param not in command_allowed_param_map[command]:
+            module.fail_json(msg='%s param is incompatible with command=%s' % (param, command))
+
+    for param in command_required_param_map.get(command, ()):
+        if not module.params[param]:
+            module.fail_json(msg='%s param is required for command=%s' % (param, command))
+
+    venv = module.params['virtualenv']
+
+    _ensure_virtualenv(module)
+
+    cmd = "python manage.py %s" % (command, )
+
+    if command in noinput_commands:
+        cmd = '%s --noinput' % cmd
+
+    for param in general_params:
+        if module.params[param]:
+            cmd = '%s --%s=%s' % (cmd, param, module.params[param])
+
+    for param in specific_boolean_params:
+        if module.boolean(module.params[param]):
+            cmd = '%s --%s' % (cmd, param)
+
+    # these params always get tacked on the end of the command
+    for param in end_of_command_params:
+        if module.params[param]:
+            cmd = '%s %s' % (cmd, module.params[param])
+
+    rc, out, err = module.run_command(cmd, cwd=app_path)
+    if rc != 0:
+        if command == 'createcachetable' and 'table' in err and 'already exists' in err:
+            out = 'Already exists.'
+        else:
+            if "Unknown command:" in err:
+                _fail(module, cmd, err, "Unknown django command: %s" % command)
+            _fail(module, cmd, out, err, path=os.environ["PATH"], syspath=sys.path)
+
+    changed = False
+
+    lines = out.split('\n')
+    filt = globals().get(command + "_filter_output", None)
+    if filt:
+        filtered_output = filter(filt, out.split('\n'))
+        if len(filtered_output):
+            changed = filtered_output
+
+    module.exit_json(changed=changed, out=out, cmd=cmd, app_path=app_path, virtualenv=virtualenv,
+                     settings=module.params['settings'], pythonpath=module.params['pythonpath'])
+
+# import module snippets
+from ansible.module_utils.basic import *
+
+main()

lib/ansible/modules/web_infrastructure/htpasswd

@@ -0,0 +1,219 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# (c) 2013, Nimbis Services, Inc.
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+DOCUMENTATION = """
+module: htpasswd
+version_added: "1.3"
+short_description: manage user files for basic authentication
+description:
+  - Add and remove username/password entries in a password file using htpasswd.
+  - This is used by web servers such as Apache and Nginx for basic authentication.
+options:
+  path:
+    required: true
+    aliases: [ dest, destfile ]
+    description:
+      - Path to the file that contains the usernames and passwords
+  name:
+    required: true
+    aliases: [ username ]
+    description:
+      - User name to add or remove
+  password:
+    required: false
+    description:
+      - Password associated with user.
+      - Must be specified if user does not exist yet.
+  crypt_scheme:
+    required: false
+    choices: ["apr_md5_crypt", "des_crypt", "ldap_sha1", "plaintext"]
+    default: "apr_md5_crypt"
+    description:
+      - Encryption scheme to be used.
+  state:
+    required: false
+    choices: [ present, absent ]
+    default: "present"
+    description:
+      - Whether the user entry should be present or not
+  create:
+    required: false
+    choices: [ "yes", "no" ]
+    default: "yes"
+    description:
+      - Used with C(state=present). If specified, the file will be created
+        if it does not already exist. If set to "no", will fail if the
+        file does not exist
+notes:
+  - "This module depends on the I(passlib) Python library, which needs to be installed on all target systems."
+  - "On Debian, Ubuntu, or Fedora: install I(python-passlib)."
+  - "On RHEL or CentOS: Enable EPEL, then install I(python-passlib)."
+requires: [ passlib>=1.6 ]
+author: Lorin Hochstein
+"""
+
+EXAMPLES = """
+# Add a user to a password file and ensure permissions are set
+- htpasswd: path=/etc/nginx/passwdfile name=janedoe password=9s36?;fyNp owner=root group=www-data mode=0640
+# Remove a user from a password file
+- htpasswd: path=/etc/apache2/passwdfile name=foobar state=absent
+"""
+
+
+import os
+from distutils.version import StrictVersion
+
+try:
+    from passlib.apache import HtpasswdFile
+    import passlib
+except ImportError:
+    passlib_installed = False
+else:
+    passlib_installed = True
+
+
+def create_missing_directories(dest):
+    destpath = os.path.dirname(dest)
+    if not os.path.exists(destpath):
+        os.makedirs(destpath)
+
+
+def present(dest, username, password, crypt_scheme, create, check_mode):
+    """ Ensures user is present
+
+    Returns (msg, changed) """
+    if not os.path.exists(dest):
+        if not create:
+            raise ValueError('Destination %s does not exist' % dest)
+        if check_mode:
+            return ("Create %s" % dest, True)
+        create_missing_directories(dest)
+        if StrictVersion(passlib.__version__) >= StrictVersion('1.6'):
+            ht = HtpasswdFile(dest, new=True, default_scheme=crypt_scheme)
+        else:
+            ht = HtpasswdFile(dest, autoload=False, default=crypt_scheme)
+        if getattr(ht, 'set_password', None):
+            ht.set_password(username, password)
+        else:
+            ht.update(username, password)
+        ht.save()
+        return ("Created %s and added %s" % (dest, username), True)
+    else:
+        if StrictVersion(passlib.__version__) >= StrictVersion('1.6'):
+            ht = HtpasswdFile(dest, new=False, default_scheme=crypt_scheme)
+        else:
+            ht = HtpasswdFile(dest, default=crypt_scheme)
+
+        found = None
+        if getattr(ht, 'check_password', None):
+            found = ht.check_password(username, password)
+        else:
+            found = ht.verify(username, password)
+
+        if found:
+            return ("%s already present" % username, False)
+        else:
+            if not check_mode:
+                if getattr(ht, 'set_password', None):
+                    ht.set_password(username, password)
+                else:
+                    ht.update(username, password)
+                ht.save()
+            return ("Add/update %s" % username, True)
+
+
+def absent(dest, username, check_mode):
+    """ Ensures user is absent
+
+    Returns (msg, changed) """
+    if not os.path.exists(dest):
+        raise ValueError("%s does not exists" % dest)
+
+    if StrictVersion(passlib.__version__) >= StrictVersion('1.6'):
+        ht = HtpasswdFile(dest, new=False)
+    else:
+        ht = HtpasswdFile(dest)
+
+    if username not in ht.users():
+        return ("%s not present" % username, False)
+    else:
+        if not check_mode:
+            ht.delete(username)
+            ht.save()
+        return ("Remove %s" % username, True)
+
+
+def check_file_attrs(module, changed, message):
+
+    file_args = module.load_file_common_arguments(module.params)
+    if module.set_fs_attributes_if_different(file_args, False):
+
+        if changed:
+            message += " and "
+        changed = True
+        message += "ownership, perms or SE linux context changed"
+
+    return message, changed
+
+
+def main():
+    arg_spec = dict(
+        path=dict(required=True, aliases=["dest", "destfile"]),
+        name=dict(required=True, aliases=["username"]),
+        password=dict(required=False, default=None),
+        crypt_scheme=dict(required=False, default=None),
+        state=dict(required=False, default="present"),
+        create=dict(type='bool', default='yes'),
+
+    )
+    module = AnsibleModule(argument_spec=arg_spec,
+                           add_file_common_args=True,
+                           supports_check_mode=True)
+
+    path = module.params['path']
+    username = module.params['name']
+    password = module.params['password']
+    crypt_scheme = module.params['crypt_scheme']
+    state = module.params['state']
+    create = module.params['create']
+    check_mode = module.check_mode
+
+    if not passlib_installed:
+        module.fail_json(msg="This module requires the passlib Python library")
+
+    try:
+        if state == 'present':
+            (msg, changed) = present(path, username, password, crypt_scheme, create, check_mode)
+        elif state == 'absent':
+            (msg, changed) = absent(path, username, check_mode)
+        else:
+            module.fail_json(msg="Invalid state: %s" % state)
+
+        check_file_attrs(module, changed, msg)
+        module.exit_json(msg=msg, changed=changed)
+    except Exception, e:
+        module.fail_json(msg=str(e))
+
+
+# import module snippets
+from ansible.module_utils.basic import *
+
+if __name__ == '__main__':
+    main()

lib/ansible/modules/web_infrastructure/supervisorctl

@@ -0,0 +1,221 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# (c) 2012, Matt Wright <matt@nobien.net>
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+import os
+
+DOCUMENTATION = '''
+---
+module: supervisorctl
+short_description: Manage the state of a program or group of programs running via supervisord
+description:
+     - Manage the state of a program or group of programs running via supervisord
+version_added: "0.7"
+options:
+  name:
+    description:
+      - The name of the supervisord program or group to manage.  
+      - The name will be taken as group name when it ends with a colon I(:)
+      - Group support is only available in Ansible version 1.6 or later.
+    required: true
+    default: null
+  config:
+    description:
+      - The supervisor configuration file path
+    required: false
+    default: null
+    version_added: "1.3"
+  server_url:
+    description:
+      - URL on which supervisord server is listening
+    required: false
+    default: null
+    version_added: "1.3"
+  username:
+    description:
+      - username to use for authentication
+    required: false
+    default: null
+    version_added: "1.3"
+  password:
+    description:
+      - password to use for authentication
+    required: false
+    default: null
+    version_added: "1.3"
+  state:
+    description:
+      - The desired state of program/group.
+    required: true
+    default: null
+    choices: [ "present", "started", "stopped", "restarted" ]
+  supervisorctl_path:
+    description:
+      - path to supervisorctl executable
+    required: false
+    default: null
+    version_added: "1.4"
+notes:
+  - When C(state) = I(present), the module will call C(supervisorctl reread) then C(supervisorctl add) if the program/group does not exist.
+  - When C(state) = I(restarted), the module will call C(supervisorctl update) then call C(supervisorctl restart).
+requirements: [ "supervisorctl" ]
+author: Matt Wright, Aaron Wang <inetfuture@gmail.com>
+'''
+
+EXAMPLES = '''
+# Manage the state of program to be in 'started' state.
+- supervisorctl: name=my_app state=started
+
+# Manage the state of program group to be in 'started' state.
+- supervisorctl: name='my_apps:' state=started
+
+# Restart my_app, reading supervisorctl configuration from a specified file.
+- supervisorctl: name=my_app state=restarted config=/var/opt/my_project/supervisord.conf
+
+# Restart my_app, connecting to supervisord with credentials and server URL.
+- supervisorctl: name=my_app state=restarted username=test password=testpass server_url=http://localhost:9001
+'''
+
+
+def main():
+    arg_spec = dict(
+        name=dict(required=True),
+        config=dict(required=False),
+        server_url=dict(required=False),
+        username=dict(required=False),
+        password=dict(required=False),
+        supervisorctl_path=dict(required=False),
+        state=dict(required=True, choices=['present', 'started', 'restarted', 'stopped'])
+    )
+
+    module = AnsibleModule(argument_spec=arg_spec, supports_check_mode=True)
+
+    name = module.params['name']
+    is_group = False
+    if name.endswith(':'):
+        is_group = True
+        name = name.rstrip(':')
+    state = module.params['state']
+    config = module.params.get('config')
+    server_url = module.params.get('server_url')
+    username = module.params.get('username')
+    password = module.params.get('password')
+    supervisorctl_path = module.params.get('supervisorctl_path')
+
+    if supervisorctl_path:
+        supervisorctl_path = os.path.expanduser(supervisorctl_path)
+        if os.path.exists(supervisorctl_path) and module.is_executable(supervisorctl_path):
+            supervisorctl_args = [supervisorctl_path]
+        else:
+            module.fail_json(
+                msg="Provided path to supervisorctl does not exist or isn't executable: %s" % supervisorctl_path)
+    else:
+        supervisorctl_args = [module.get_bin_path('supervisorctl', True)]
+
+    if config:
+        supervisorctl_args.extend(['-c', os.path.expanduser(config)])
+    if server_url:
+        supervisorctl_args.extend(['-s', server_url])
+    if username:
+        supervisorctl_args.extend(['-u', username])
+    if password:
+        supervisorctl_args.extend(['-p', password])
+
+    def run_supervisorctl(cmd, name=None, **kwargs):
+        args = list(supervisorctl_args)  # copy the master args
+        args.append(cmd)
+        if name:
+            args.append(name)
+        return module.run_command(args, **kwargs)
+
+    def get_matched_processes():
+        matched = []
+        rc, out, err = run_supervisorctl('status')
+        for line in out.splitlines():
+            # One status line may look like one of these two:
+            # process not in group:
+            #   echo_date_lonely RUNNING pid 7680, uptime 13:22:18
+            # process in group:
+            #   echo_date_group:echo_date_00 RUNNING pid 7681, uptime 13:22:18
+            fields = [field for field in line.split(' ') if field != '']
+            process_name = fields[0]
+            status = fields[1]
+
+            if is_group:
+                # If there is ':', this process must be in a group.
+                if ':' in process_name:
+                    group = process_name.split(':')[0]
+                    if group != name:
+                        continue
+                else:
+                    continue
+            else:
+                if process_name != name:
+                    continue
+
+            matched.append((process_name, status))
+        return matched
+
+    def take_action_on_processes(processes, status_filter, action, expected_result):
+        to_take_action_on = []
+        for process_name, status in processes:
+            if status_filter(status):
+                to_take_action_on.append(process_name)
+
+        if len(to_take_action_on) == 0:
+            module.exit_json(changed=False, name=name, state=state)
+        if module.check_mode:
+            module.exit_json(changed=True)
+        for process_name in to_take_action_on:
+            rc, out, err = run_supervisorctl(action, process_name)
+            if '%s: %s' % (process_name, expected_result) not in out:
+                module.fail_json(msg=out)
+
+        module.exit_json(changed=True, name=name, state=state, affected=to_take_action_on)
+
+    if state == 'restarted':
+        rc, out, err = run_supervisorctl('update')
+        processes = get_matched_processes()
+        take_action_on_processes(processes, lambda s: True, 'restart', 'started')
+
+    processes = get_matched_processes()
+
+    if state == 'present':
+        if len(processes) > 0:
+            module.exit_json(changed=False, name=name, state=state)
+
+        if module.check_mode:
+            module.exit_json(changed=True)
+        run_supervisorctl('reread', check_rc=True)
+        rc, out, err = run_supervisorctl('add', name)
+        if '%s: added process group' % name in out:
+            module.exit_json(changed=True, name=name, state=state)
+        else:
+            module.fail_json(msg=out, name=name, state=state)
+
+    if state == 'started':
+        take_action_on_processes(processes, lambda s: s != 'RUNNING', 'start', 'started')
+
+    if state == 'stopped':
+        take_action_on_processes(processes, lambda s: s == 'RUNNING', 'stop', 'stopped')
+
+# import module snippets
+from ansible.module_utils.basic import *
+
+main()