Restructuring.

lib/ansible/modules/database/mysql_db

@@ -0,0 +1,363 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# (c) 2012, Mark Theunissen <mark.theunissen@gmail.com>
+# Sponsored by Four Kitchens http://fourkitchens.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: mysql_db
+short_description: Add or remove MySQL databases from a remote host.
+description:
+   - Add or remove MySQL databases from a remote host.
+version_added: "0.6"
+options:
+  name:
+    description:
+      - name of the database to add or remove
+    required: true
+    default: null
+    aliases: [ db ]
+  login_user:
+    description:
+      - The username used to authenticate with
+    required: false
+    default: null
+  login_password:
+    description:
+      - The password used to authenticate with
+    required: false
+    default: null
+  login_host:
+    description:
+      - Host running the database
+    required: false
+    default: localhost
+  login_port:
+    description:
+      - Port of the MySQL server. Requires login_host be defined as other then localhost if login_port is used
+    required: false
+    default: 3306
+  login_unix_socket:
+    description:
+      - The path to a Unix domain socket for local connections
+    required: false
+    default: null
+  state:
+    description:
+      - The database state
+    required: false
+    default: present
+    choices: [ "present", "absent", "dump", "import" ]
+  collation:
+    description:
+      - Collation mode
+    required: false
+    default: null
+  encoding:
+    description:
+      - Encoding mode
+    required: false
+    default: null
+  target:
+    description:
+      - Location, on the remote host, of the dump file to read from or write to. Uncompressed SQL
+        files (C(.sql)) as well as bzip2 (C(.bz2)) and gzip (C(.gz)) compressed files are supported.
+    required: false
+notes:
+   - Requires the MySQLdb Python package on the remote host. For Ubuntu, this
+     is as easy as apt-get install python-mysqldb. (See M(apt).)
+   - Both I(login_password) and I(login_user) are required when you are
+     passing credentials. If none are present, the module will attempt to read
+     the credentials from C(~/.my.cnf), and finally fall back to using the MySQL
+     default login of C(root) with no password.
+requirements: [ ConfigParser ]
+author: Mark Theunissen
+'''
+
+EXAMPLES = '''
+# Create a new database with name 'bobdata'
+- mysql_db: name=bobdata state=present
+
+# Copy database dump file to remote host and restore it to database 'my_db'
+- copy: src=dump.sql.bz2 dest=/tmp
+- mysql_db: name=my_db state=import target=/tmp/dump.sql.bz2
+'''
+
+import ConfigParser
+import os
+import pipes
+try:
+    import MySQLdb
+except ImportError:
+    mysqldb_found = False
+else:
+    mysqldb_found = True
+
+# ===========================================
+# MySQL module specific support methods.
+#
+
+def db_exists(cursor, db):
+    res = cursor.execute("SHOW DATABASES LIKE %s", (db.replace("_","\_"),))
+    return bool(res)
+
+def db_delete(cursor, db):
+    query = "DROP DATABASE `%s`" % db
+    cursor.execute(query)
+    return True
+
+def db_dump(module, host, user, password, db_name, target, port, socket=None):
+    cmd = module.get_bin_path('mysqldump', True)
+    cmd += " --quick --user=%s --password=%s" % (pipes.quote(user), pipes.quote(password))
+    if socket is not None:
+        cmd += " --socket=%s" % pipes.quote(socket)
+    else:
+        cmd += " --host=%s --port=%s" % (pipes.quote(host), pipes.quote(port))
+    cmd += " %s" % pipes.quote(db_name)
+    if os.path.splitext(target)[-1] == '.gz':
+        cmd = cmd + ' | gzip > ' + pipes.quote(target)
+    elif os.path.splitext(target)[-1] == '.bz2':
+        cmd = cmd + ' | bzip2 > ' + pipes.quote(target)
+    else:
+        cmd += " > %s" % pipes.quote(target)
+    rc, stdout, stderr = module.run_command(cmd, use_unsafe_shell=True)
+    return rc, stdout, stderr
+
+def db_import(module, host, user, password, db_name, target, port, socket=None):
+    if not os.path.exists(target):
+        return module.fail_json(msg="target %s does not exist on the host" % target)
+
+    cmd = module.get_bin_path('mysql', True)
+    cmd += " --user=%s --password=%s" % (pipes.quote(user), pipes.quote(password))
+    if socket is not None:
+        cmd += " --socket=%s" % pipes.quote(socket)
+    else:
+        cmd += " --host=%s --port=%s" % (pipes.quote(host), pipes.quote(port))
+    cmd += " -D %s" % pipes.quote(db_name)
+    if os.path.splitext(target)[-1] == '.gz':
+        gunzip_path = module.get_bin_path('gunzip')
+        if gunzip_path:
+            rc, stdout, stderr = module.run_command('%s %s' % (gunzip_path, target))
+            if rc != 0:
+                return rc, stdout, stderr
+            cmd += " < %s" % pipes.quote(os.path.splitext(target)[0])
+            rc, stdout, stderr = module.run_command(cmd, use_unsafe_shell=True)
+            if rc != 0:
+                return rc, stdout, stderr
+            gzip_path = module.get_bin_path('gzip')
+            if gzip_path:
+                rc, stdout, stderr = module.run_command('%s %s' % (gzip_path, os.path.splitext(target)[0]))
+            else:
+                module.fail_json(msg="gzip command not found")
+        else:
+            module.fail_json(msg="gunzip command not found")
+    elif os.path.splitext(target)[-1] == '.bz2':
+        bunzip2_path = module.get_bin_path('bunzip2')
+        if bunzip2_path:
+            rc, stdout, stderr = module.run_command('%s %s' % (bunzip2_path, target))
+            if rc != 0:
+                return rc, stdout, stderr
+            cmd += " < %s" % pipes.quote(os.path.splitext(target)[0])
+            rc, stdout, stderr = module.run_command(cmd, use_unsafe_shell=True)
+            if rc != 0:
+                return rc, stdout, stderr
+            bzip2_path = module.get_bin_path('bzip2')
+            if bzip2_path:
+                rc, stdout, stderr = module.run_command('%s %s' % (bzip2_path, os.path.splitext(target)[0]))
+            else:
+                module.fail_json(msg="bzip2 command not found")
+        else:
+            module.fail_json(msg="bunzip2 command not found")
+    else:
+        cmd += " < %s" % pipes.quote(target)
+        rc, stdout, stderr = module.run_command(cmd, use_unsafe_shell=True)
+    return rc, stdout, stderr
+
+def db_create(cursor, db, encoding, collation):
+    if encoding:
+        encoding = " CHARACTER SET %s" % encoding
+    if collation:
+        collation = " COLLATE %s" % collation
+    query = "CREATE DATABASE `%s`%s%s" % (db, encoding, collation)
+    res = cursor.execute(query)
+    return True
+
+def strip_quotes(s):
+    """ Remove surrounding single or double quotes
+
+    >>> print strip_quotes('hello')
+    hello
+    >>> print strip_quotes('"hello"')
+    hello
+    >>> print strip_quotes("'hello'")
+    hello
+    >>> print strip_quotes("'hello")
+    'hello
+
+    """
+    single_quote = "'"
+    double_quote = '"'
+
+    if s.startswith(single_quote) and s.endswith(single_quote):
+        s = s.strip(single_quote)
+    elif s.startswith(double_quote) and s.endswith(double_quote):
+        s = s.strip(double_quote)
+    return s
+
+
+def config_get(config, section, option):
+    """ Calls ConfigParser.get and strips quotes
+
+    See: http://dev.mysql.com/doc/refman/5.0/en/option-files.html
+    """
+    return strip_quotes(config.get(section, option))
+
+
+def load_mycnf():
+    config = ConfigParser.RawConfigParser()
+    mycnf = os.path.expanduser('~/.my.cnf')
+    if not os.path.exists(mycnf):
+        return False
+    try:
+        config.readfp(open(mycnf))
+    except (IOError):
+        return False
+    # We support two forms of passwords in .my.cnf, both pass= and password=,
+    # as these are both supported by MySQL.
+    try:
+        passwd = config_get(config, 'client', 'password')
+    except (ConfigParser.NoOptionError):
+        try:
+            passwd = config_get(config, 'client', 'pass')
+        except (ConfigParser.NoOptionError):
+            return False
+    try:
+        creds = dict(user=config_get(config, 'client', 'user'),passwd=passwd)
+    except (ConfigParser.NoOptionError):
+        return False
+    return creds
+
+# ===========================================
+# Module execution.
+#
+
+def main():
+    module = AnsibleModule(
+        argument_spec = dict(
+            login_user=dict(default=None),
+            login_password=dict(default=None),
+            login_host=dict(default="localhost"),
+            login_port=dict(default="3306"),
+            login_unix_socket=dict(default=None),
+            name=dict(required=True, aliases=['db']),
+            encoding=dict(default=""),
+            collation=dict(default=""),
+            target=dict(default=None),
+            state=dict(default="present", choices=["absent", "present","dump", "import"]),
+        )
+    )
+
+    if not mysqldb_found:
+        module.fail_json(msg="the python mysqldb module is required")
+
+    db = module.params["name"]
+    encoding = module.params["encoding"]
+    collation = module.params["collation"]
+    state = module.params["state"]
+    target = module.params["target"]
+
+    # make sure the target path is expanded for ~ and $HOME
+    if target is not None:
+        target = os.path.expandvars(os.path.expanduser(target))
+
+    # Either the caller passes both a username and password with which to connect to
+    # mysql, or they pass neither and allow this module to read the credentials from
+    # ~/.my.cnf.
+    login_password = module.params["login_password"]
+    login_user = module.params["login_user"]
+    if login_user is None and login_password is None:
+        mycnf_creds = load_mycnf()
+        if mycnf_creds is False:
+            login_user = "root"
+            login_password = ""
+        else:
+            login_user = mycnf_creds["user"]
+            login_password = mycnf_creds["passwd"]
+    elif login_password is None or login_user is None:
+        module.fail_json(msg="when supplying login arguments, both login_user and login_password must be provided")
+    login_host = module.params["login_host"]
+
+    if state in ['dump','import']:
+        if target is None:
+            module.fail_json(msg="with state=%s target is required" % (state))
+        connect_to_db = db
+    else:
+        connect_to_db = 'mysql'
+    try:
+        if module.params["login_unix_socket"]:
+            db_connection = MySQLdb.connect(host=module.params["login_host"], unix_socket=module.params["login_unix_socket"], user=login_user, passwd=login_password, db=connect_to_db)
+        elif module.params["login_port"] != "3306" and module.params["login_host"] == "localhost":
+            module.fail_json(msg="login_host is required when login_port is defined, login_host cannot be localhost when login_port is defined")
+        else:
+            db_connection = MySQLdb.connect(host=module.params["login_host"], port=int(module.params["login_port"]), user=login_user, passwd=login_password, db=connect_to_db)
+        cursor = db_connection.cursor()
+    except Exception, e:
+        if "Unknown database" in str(e):
+                errno, errstr = e.args
+                module.fail_json(msg="ERROR: %s %s" % (errno, errstr))
+        else:
+                module.fail_json(msg="unable to connect, check login_user and login_password are correct, or alternatively check ~/.my.cnf contains credentials")
+
+    changed = False
+    if db_exists(cursor, db):
+        if state == "absent":
+            try:
+                changed = db_delete(cursor, db)
+            except Exception, e:
+                module.fail_json(msg="error deleting database: " + str(e))
+        elif state == "dump":
+            rc, stdout, stderr = db_dump(module, login_host, login_user, 
+                                        login_password, db, target, 
+                                        port=module.params['login_port'],
+                                        socket=module.params['login_unix_socket'])
+            if rc != 0:
+                module.fail_json(msg="%s" % stderr)
+            else:
+                module.exit_json(changed=True, db=db, msg=stdout)
+        elif state == "import":
+            rc, stdout, stderr = db_import(module, login_host, login_user, 
+                                        login_password, db, target, 
+                                        port=module.params['login_port'],
+                                        socket=module.params['login_unix_socket'])
+            if rc != 0:
+                module.fail_json(msg="%s" % stderr)
+            else:
+                module.exit_json(changed=True, db=db, msg=stdout)
+    else:
+        if state == "present":
+            try:
+                changed = db_create(cursor, db, encoding, collation)
+            except Exception, e:
+                module.fail_json(msg="error creating database: " + str(e))
+
+    module.exit_json(changed=changed, db=db)
+
+# import module snippets
+from ansible.module_utils.basic import *
+main()

lib/ansible/modules/database/mysql_user

@@ -0,0 +1,476 @@
+#!/usr/bin/python
+
+# (c) 2012, Mark Theunissen <mark.theunissen@gmail.com>
+# Sponsored by Four Kitchens http://fourkitchens.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: mysql_user
+short_description: Adds or removes a user from a MySQL database.
+description:
+   - Adds or removes a user from a MySQL database.
+version_added: "0.6"
+options:
+  name:
+    description:
+      - name of the user (role) to add or remove
+    required: true
+    default: null
+  password:
+    description:
+      - set the user's password
+    required: false
+    default: null
+  host:
+    description:
+      - the 'host' part of the MySQL username
+    required: false
+    default: localhost
+  login_user:
+    description:
+      - The username used to authenticate with
+    required: false
+    default: null
+  login_password:
+    description:
+      - The password used to authenticate with
+    required: false
+    default: null
+  login_host:
+    description:
+      - Host running the database
+    required: false
+    default: localhost
+  login_port:
+    description:
+      - Port of the MySQL server
+    required: false
+    default: 3306
+    version_added: '1.4'
+  login_unix_socket:
+    description:
+      - The path to a Unix domain socket for local connections
+    required: false
+    default: null
+  priv:
+    description:
+      - "MySQL privileges string in the format: C(db.table:priv1,priv2)"
+    required: false
+    default: null
+  append_privs:
+    description:
+      - Append the privileges defined by priv to the existing ones for this
+        user instead of overwriting existing ones.
+    required: false
+    choices: [ "yes", "no" ]
+    default: "no"
+    version_added: "1.4"
+  state:
+    description:
+      - Whether the user should exist.  When C(absent), removes
+        the user.
+    required: false
+    default: present
+    choices: [ "present", "absent" ]
+  check_implicit_admin:
+    description:
+      - Check if mysql allows login as root/nopassword before trying supplied credentials.
+    required: false
+    default: false
+    version_added: "1.3"
+notes:
+   - Requires the MySQLdb Python package on the remote host. For Ubuntu, this
+     is as easy as apt-get install python-mysqldb.
+   - Both C(login_password) and C(login_username) are required when you are
+     passing credentials. If none are present, the module will attempt to read
+     the credentials from C(~/.my.cnf), and finally fall back to using the MySQL
+     default login of 'root' with no password.
+   - "MySQL server installs with default login_user of 'root' and no password. To secure this user
+     as part of an idempotent playbook, you must create at least two tasks: the first must change the root user's password,
+     without providing any login_user/login_password details. The second must drop a ~/.my.cnf file containing
+     the new root credentials. Subsequent runs of the playbook will then succeed by reading the new credentials from
+     the file."
+
+requirements: [ "ConfigParser", "MySQLdb" ]
+author: Mark Theunissen
+'''
+
+EXAMPLES = """
+# Create database user with name 'bob' and password '12345' with all database privileges
+- mysql_user: name=bob password=12345 priv=*.*:ALL state=present
+
+# Creates database user 'bob' and password '12345' with all database privileges and 'WITH GRANT OPTION'
+- mysql_user: name=bob password=12345 priv=*.*:ALL,GRANT state=present
+
+# Ensure no user named 'sally' exists, also passing in the auth credentials.
+- mysql_user: login_user=root login_password=123456 name=sally state=absent
+
+# Specify grants composed of more than one word
+- mysql_user: name=replication password=12345 priv=*.*:"REPLICATION CLIENT" state=present
+
+# Revoke all privileges for user 'bob' and password '12345' 
+- mysql_user: name=bob password=12345 priv=*.*:USAGE state=present
+
+# Example privileges string format
+mydb.*:INSERT,UPDATE/anotherdb.*:SELECT/yetanotherdb.*:ALL
+
+# Example using login_unix_socket to connect to server
+- mysql_user: name=root password=abc123 login_unix_socket=/var/run/mysqld/mysqld.sock
+
+# Example .my.cnf file for setting the root password
+# Note: don't use quotes around the password, because the mysql_user module
+# will include them in the password but the mysql client will not
+
+[client]
+user=root
+password=n<_665{vS43y
+"""
+
+import ConfigParser
+import getpass
+import tempfile
+try:
+    import MySQLdb
+except ImportError:
+    mysqldb_found = False
+else:
+    mysqldb_found = True
+
+# ===========================================
+# MySQL module specific support methods.
+#
+
+def user_exists(cursor, user, host):
+    cursor.execute("SELECT count(*) FROM user WHERE user = %s AND host = %s", (user,host))
+    count = cursor.fetchone()
+    return count[0] > 0
+
+def user_add(cursor, user, host, password, new_priv):
+    cursor.execute("CREATE USER %s@%s IDENTIFIED BY %s", (user,host,password))
+    if new_priv is not None:
+        for db_table, priv in new_priv.iteritems():
+            privileges_grant(cursor, user,host,db_table,priv)
+    return True
+
+def user_mod(cursor, user, host, password, new_priv, append_privs):
+    changed = False
+    grant_option = False
+
+    # Handle passwords.
+    if password is not None:
+        cursor.execute("SELECT password FROM user WHERE user = %s AND host = %s", (user,host))
+        current_pass_hash = cursor.fetchone()
+        cursor.execute("SELECT PASSWORD(%s)", (password,))
+        new_pass_hash = cursor.fetchone()
+        if current_pass_hash[0] != new_pass_hash[0]:
+            cursor.execute("SET PASSWORD FOR %s@%s = PASSWORD(%s)", (user,host,password))
+            changed = True
+
+    # Handle privileges.
+    if new_priv is not None:
+        curr_priv = privileges_get(cursor, user,host)
+
+        # If the user has privileges on a db.table that doesn't appear at all in
+        # the new specification, then revoke all privileges on it.
+        for db_table, priv in curr_priv.iteritems():
+            # If the user has the GRANT OPTION on a db.table, revoke it first.
+            if "GRANT" in priv:
+                grant_option = True
+            if db_table not in new_priv:
+                if user != "root" and "PROXY" not in priv and not append_privs:
+                    privileges_revoke(cursor, user,host,db_table,grant_option)
+                    changed = True
+
+        # If the user doesn't currently have any privileges on a db.table, then
+        # we can perform a straight grant operation.
+        for db_table, priv in new_priv.iteritems():
+            if db_table not in curr_priv:
+                privileges_grant(cursor, user,host,db_table,priv)
+                changed = True
+
+        # If the db.table specification exists in both the user's current privileges
+        # and in the new privileges, then we need to see if there's a difference.
+        db_table_intersect = set(new_priv.keys()) & set(curr_priv.keys())
+        for db_table in db_table_intersect:
+            priv_diff = set(new_priv[db_table]) ^ set(curr_priv[db_table])
+            if (len(priv_diff) > 0):
+                if not append_privs:
+                    privileges_revoke(cursor, user,host,db_table,grant_option)
+                privileges_grant(cursor, user,host,db_table,new_priv[db_table])
+                changed = True
+
+    return changed
+
+def user_delete(cursor, user, host):
+    cursor.execute("DROP USER %s@%s", (user,host))
+    return True
+
+def privileges_get(cursor, user,host):
+    """ MySQL doesn't have a better method of getting privileges aside from the
+    SHOW GRANTS query syntax, which requires us to then parse the returned string.
+    Here's an example of the string that is returned from MySQL:
+
+     GRANT USAGE ON *.* TO 'user'@'localhost' IDENTIFIED BY 'pass';
+
+    This function makes the query and returns a dictionary containing the results.
+    The dictionary format is the same as that returned by privileges_unpack() below.
+    """
+    output = {}
+    cursor.execute("SHOW GRANTS FOR %s@%s", (user,host))
+    grants = cursor.fetchall()
+
+    def pick(x):
+        if x == 'ALL PRIVILEGES':
+            return 'ALL'
+        else:
+            return x
+
+    for grant in grants:
+        res = re.match("GRANT (.+) ON (.+) TO '.+'@'.+'( IDENTIFIED BY PASSWORD '.+')? ?(.*)", grant[0])
+        if res is None:
+            module.fail_json(msg="unable to parse the MySQL grant string")
+        privileges = res.group(1).split(", ")
+        privileges = [ pick(x) for x in privileges]
+        if "WITH GRANT OPTION" in res.group(4):
+            privileges.append('GRANT')
+        db = res.group(2)
+        output[db] = privileges
+    return output
+
+def privileges_unpack(priv):
+    """ Take a privileges string, typically passed as a parameter, and unserialize
+    it into a dictionary, the same format as privileges_get() above. We have this
+    custom format to avoid using YAML/JSON strings inside YAML playbooks. Example
+    of a privileges string:
+
+     mydb.*:INSERT,UPDATE/anotherdb.*:SELECT/yetanother.*:ALL
+
+    The privilege USAGE stands for no privileges, so we add that in on *.* if it's
+    not specified in the string, as MySQL will always provide this by default.
+    """
+    output = {}
+    for item in priv.split('/'):
+        pieces = item.split(':')
+        if '.' in pieces[0]:
+            pieces[0] = pieces[0].split('.')
+            for idx, piece in enumerate(pieces):
+                if pieces[0][idx] != "*":
+                    pieces[0][idx] = "`" + pieces[0][idx] + "`"
+            pieces[0] = '.'.join(pieces[0])
+
+        output[pieces[0]] = pieces[1].upper().split(',')
+
+    if '*.*' not in output:
+        output['*.*'] = ['USAGE']
+
+    return output
+
+def privileges_revoke(cursor, user,host,db_table,grant_option):
+    if grant_option:
+        query = "REVOKE GRANT OPTION ON %s FROM '%s'@'%s'" % (db_table,user,host)
+        cursor.execute(query)
+    query = "REVOKE ALL PRIVILEGES ON %s FROM '%s'@'%s'" % (db_table,user,host)
+    cursor.execute(query)
+
+def privileges_grant(cursor, user,host,db_table,priv):
+
+    priv_string = ",".join(filter(lambda x: x != 'GRANT', priv))
+    query = "GRANT %s ON %s TO '%s'@'%s'" % (priv_string,db_table,user,host)
+    if 'GRANT' in priv:
+        query = query + " WITH GRANT OPTION"
+    cursor.execute(query)
+
+
+def strip_quotes(s):
+    """ Remove surrounding single or double quotes
+
+    >>> print strip_quotes('hello')
+    hello
+    >>> print strip_quotes('"hello"')
+    hello
+    >>> print strip_quotes("'hello'")
+    hello
+    >>> print strip_quotes("'hello")
+    'hello
+
+    """
+    single_quote = "'"
+    double_quote = '"'
+
+    if s.startswith(single_quote) and s.endswith(single_quote):
+        s = s.strip(single_quote)
+    elif s.startswith(double_quote) and s.endswith(double_quote):
+        s = s.strip(double_quote)
+    return s
+
+
+def config_get(config, section, option):
+    """ Calls ConfigParser.get and strips quotes
+
+    See: http://dev.mysql.com/doc/refman/5.0/en/option-files.html
+    """
+    return strip_quotes(config.get(section, option))
+
+
+def _safe_cnf_load(config, path):
+
+    data = {'user':'', 'password':''}
+
+    # read in user/pass
+    f = open(path, 'r')
+    for line in f.readlines():
+        line = line.strip()
+        if line.startswith('user='):
+            data['user'] = line.split('=', 1)[1].strip()
+        if line.startswith('password=') or line.startswith('pass='):
+            data['password'] = line.split('=', 1)[1].strip()
+    f.close()
+
+    # write out a new cnf file with only user/pass   
+    fh, newpath = tempfile.mkstemp(prefix=path + '.')
+    f = open(newpath, 'wb')
+    f.write('[client]\n')
+    f.write('user=%s\n' % data['user'])
+    f.write('password=%s\n' % data['password'])
+    f.close()
+
+    config.readfp(open(newpath))
+    os.remove(newpath)
+    return config
+
+def load_mycnf():
+    config = ConfigParser.RawConfigParser()
+    mycnf = os.path.expanduser('~/.my.cnf')
+    if not os.path.exists(mycnf):
+        return False
+    try:
+        config.readfp(open(mycnf))
+    except (IOError):
+        return False
+    except:
+        config = _safe_cnf_load(config, mycnf)
+
+    # We support two forms of passwords in .my.cnf, both pass= and password=,
+    # as these are both supported by MySQL.
+    try:
+        passwd = config_get(config, 'client', 'password')
+    except (ConfigParser.NoOptionError):
+        try:
+            passwd = config_get(config, 'client', 'pass')
+        except (ConfigParser.NoOptionError):
+            return False
+
+    # If .my.cnf doesn't specify a user, default to user login name
+    try:
+        user = config_get(config, 'client', 'user')
+    except (ConfigParser.NoOptionError):
+        user = getpass.getuser()
+    creds = dict(user=user,passwd=passwd)
+    return creds
+
+def connect(module, login_user, login_password):
+    if module.params["login_unix_socket"]:
+        db_connection = MySQLdb.connect(host=module.params["login_host"], unix_socket=module.params["login_unix_socket"], user=login_user, passwd=login_password, db="mysql")
+    else:
+        db_connection = MySQLdb.connect(host=module.params["login_host"], port=int(module.params["login_port"]), user=login_user, passwd=login_password, db="mysql")
+    return db_connection.cursor()
+
+# ===========================================
+# Module execution.
+#
+
+def main():
+    module = AnsibleModule(
+        argument_spec = dict(
+            login_user=dict(default=None),
+            login_password=dict(default=None),
+            login_host=dict(default="localhost"),
+            login_port=dict(default="3306"),
+            login_unix_socket=dict(default=None),
+            user=dict(required=True, aliases=['name']),
+            password=dict(default=None),
+            host=dict(default="localhost"),
+            state=dict(default="present", choices=["absent", "present"]),
+            priv=dict(default=None),
+            append_privs=dict(type="bool", default="no"),
+            check_implicit_admin=dict(default=False),
+        )
+    )
+    user = module.params["user"]
+    password = module.params["password"]
+    host = module.params["host"]
+    state = module.params["state"]
+    priv = module.params["priv"]
+    check_implicit_admin = module.params['check_implicit_admin']
+    append_privs = module.boolean(module.params["append_privs"])
+
+    if not mysqldb_found:
+        module.fail_json(msg="the python mysqldb module is required")
+
+    if priv is not None:
+        try:
+            priv = privileges_unpack(priv)
+        except:
+            module.fail_json(msg="invalid privileges string")
+
+    # Either the caller passes both a username and password with which to connect to
+    # mysql, or they pass neither and allow this module to read the credentials from
+    # ~/.my.cnf.
+    login_password = module.params["login_password"]
+    login_user = module.params["login_user"]
+    if login_user is None and login_password is None:
+        mycnf_creds = load_mycnf()
+        if mycnf_creds is False:
+            login_user = "root"
+            login_password = ""
+        else:
+            login_user = mycnf_creds["user"]
+            login_password = mycnf_creds["passwd"]
+    elif login_password is None or login_user is None:
+        module.fail_json(msg="when supplying login arguments, both login_user and login_password must be provided")
+
+    cursor = None
+    try:
+        if check_implicit_admin:
+            try:
+                cursor = connect(module, 'root', '')
+            except:
+                pass
+
+        if not cursor:
+            cursor = connect(module, login_user, login_password)
+    except Exception, e:
+        module.fail_json(msg="unable to connect to database, check login_user and login_password are correct or ~/.my.cnf has the credentials")
+
+    if state == "present":
+        if user_exists(cursor, user, host):
+            changed = user_mod(cursor, user, host, password, priv, append_privs)
+        else:
+            if password is None:
+                module.fail_json(msg="password parameter required when adding a user")
+            changed = user_add(cursor, user, host, password, priv)
+    elif state == "absent":
+        if user_exists(cursor, user, host):
+            changed = user_delete(cursor, user, host)
+        else:
+            changed = False
+    module.exit_json(changed=changed, user=user)
+
+# import module snippets
+from ansible.module_utils.basic import *
+main()

lib/ansible/modules/database/mysql_variables

@@ -0,0 +1,253 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+
+Ansible module to manage mysql variables
+(c) 2013, Balazs Pocze <banyek@gawker.com>
+Certain parts are taken from Mark Theunissen's mysqldb module
+
+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: mysql_variables
+
+short_description: Manage MySQL global variables
+description:
+    - Query / Set MySQL variables
+version_added: 1.3
+options:
+    variable:
+        description:
+            - Variable name to operate
+        required: True
+    value:
+        description:
+            - If set, then sets variable value to this
+        required: False
+    login_user:
+        description:
+            - username to connect mysql host, if defined login_password also needed.
+        required: False
+    login_password:
+        description:
+            - password to connect mysql host, if defined login_user also needed.
+        required: False
+    login_host:
+        description:
+            - mysql host to connect
+        required: False
+    login_unix_socket:
+        description:
+            - unix socket to connect mysql server
+'''
+EXAMPLES = '''
+# Check for sync_binlog setting
+- mysql_variables: variable=sync_binlog
+
+# Set read_only variable to 1
+- mysql_variables: variable=read_only value=1
+'''
+
+
+import ConfigParser
+import os
+import warnings
+
+try:
+    import MySQLdb
+except ImportError:
+    mysqldb_found = False
+else:
+    mysqldb_found = True
+
+
+def typedvalue(value):
+    """
+    Convert value to number whenever possible, return same value
+    otherwise.
+
+    >>> typedvalue('3')
+    3
+    >>> typedvalue('3.0')
+    3.0
+    >>> typedvalue('foobar')
+    'foobar'
+
+    """
+    try:
+        return int(value)
+    except ValueError:
+        pass
+
+    try:
+        return float(value)
+    except ValueError:
+        pass
+
+    return value
+
+
+def getvariable(cursor, mysqlvar):
+    cursor.execute("SHOW VARIABLES LIKE '" + mysqlvar + "'")
+    mysqlvar_val = cursor.fetchall()
+    return mysqlvar_val
+
+
+def setvariable(cursor, mysqlvar, value):
+    """ Set a global mysql variable to a given value
+
+    The DB driver will handle quoting of the given value based on its
+    type, thus numeric strings like '3.0' or '8' are illegal, they
+    should be passed as numeric literals.
+
+    """
+    try:
+        cursor.execute("SET GLOBAL " + mysqlvar + " = %s", (value,))
+        cursor.fetchall()
+        result = True
+    except Exception, e:
+        result = str(e)
+    return result
+
+
+def strip_quotes(s):
+    """ Remove surrounding single or double quotes
+
+    >>> print strip_quotes('hello')
+    hello
+    >>> print strip_quotes('"hello"')
+    hello
+    >>> print strip_quotes("'hello'")
+    hello
+    >>> print strip_quotes("'hello")
+    'hello
+
+    """
+    single_quote = "'"
+    double_quote = '"'
+
+    if s.startswith(single_quote) and s.endswith(single_quote):
+        s = s.strip(single_quote)
+    elif s.startswith(double_quote) and s.endswith(double_quote):
+        s = s.strip(double_quote)
+    return s
+
+
+def config_get(config, section, option):
+    """ Calls ConfigParser.get and strips quotes
+
+    See: http://dev.mysql.com/doc/refman/5.0/en/option-files.html
+    """
+    return strip_quotes(config.get(section, option))
+
+
+def load_mycnf():
+    config = ConfigParser.RawConfigParser()
+    mycnf = os.path.expanduser('~/.my.cnf')
+    if not os.path.exists(mycnf):
+        return False
+    try:
+        config.readfp(open(mycnf))
+    except (IOError):
+        return False
+    # We support two forms of passwords in .my.cnf, both pass= and password=,
+    # as these are both supported by MySQL.
+    try:
+        passwd = config_get(config, 'client', 'password')
+    except (ConfigParser.NoOptionError):
+        try:
+            passwd = config_get(config, 'client', 'pass')
+        except (ConfigParser.NoOptionError):
+            return False
+
+    # If .my.cnf doesn't specify a user, default to user login name
+    try:
+        user = config_get(config, 'client', 'user')
+    except (ConfigParser.NoOptionError):
+        user = getpass.getuser()
+    creds = dict(user=user, passwd=passwd)
+    return creds
+
+
+def main():
+    module = AnsibleModule(
+            argument_spec = dict(
+            login_user=dict(default=None),
+            login_password=dict(default=None),
+            login_host=dict(default="localhost"),
+            login_unix_socket=dict(default=None),
+            variable=dict(default=None),
+            value=dict(default=None)
+
+        )
+    )
+    user = module.params["login_user"]
+    password = module.params["login_password"]
+    host = module.params["login_host"]
+    mysqlvar = module.params["variable"]
+    value = module.params["value"]
+    if not mysqldb_found:
+        module.fail_json(msg="the python mysqldb module is required")
+    else:
+        warnings.filterwarnings('error', category=MySQLdb.Warning)
+
+    # Either the caller passes both a username and password with which to connect to
+    # mysql, or they pass neither and allow this module to read the credentials from
+    # ~/.my.cnf.
+    login_password = module.params["login_password"]
+    login_user = module.params["login_user"]
+    if login_user is None and login_password is None:
+        mycnf_creds = load_mycnf()
+        if mycnf_creds is False:
+            login_user = "root"
+            login_password = ""
+        else:
+            login_user = mycnf_creds["user"]
+            login_password = mycnf_creds["passwd"]
+    elif login_password is None or login_user is None:
+        module.fail_json(msg="when supplying login arguments, both login_user and login_password must be provided")
+    try:
+        if module.params["login_unix_socket"]:
+            db_connection = MySQLdb.connect(host=module.params["login_host"], unix_socket=module.params["login_unix_socket"], user=login_user, passwd=login_password, db="mysql")
+        else:
+            db_connection = MySQLdb.connect(host=module.params["login_host"], user=login_user, passwd=login_password, db="mysql")
+        cursor = db_connection.cursor()
+    except Exception, e:
+        module.fail_json(msg="unable to connect to database, check login_user and login_password are correct or ~/.my.cnf has the credentials")
+    if mysqlvar is None:
+        module.fail_json(msg="Cannot run without variable to operate with")
+    mysqlvar_val = getvariable(cursor, mysqlvar)
+    if value is None:
+        module.exit_json(msg=mysqlvar_val)
+    else:
+        if len(mysqlvar_val) < 1:
+            module.fail_json(msg="Variable not available", changed=False)
+        # Type values before using them
+        value_wanted = typedvalue(value)
+        value_actual = typedvalue(mysqlvar_val[0][1])
+        if value_wanted == value_actual:
+            module.exit_json(msg="Variable already set to requested value", changed=False)
+        result = setvariable(cursor, mysqlvar, value_wanted)
+        if result is True:
+            module.exit_json(msg="Variable change succeeded prev_value=%s" % value_actual, changed=True)
+        else:
+            module.fail_json(msg=result, changed=False)
+
+# import module snippets
+from ansible.module_utils.basic import *
+main()

lib/ansible/modules/database/postgresql_db

@@ -0,0 +1,301 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# 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: postgresql_db
+short_description: Add or remove PostgreSQL databases from a remote host.
+description:
+   - Add or remove PostgreSQL databases from a remote host.
+version_added: "0.6"
+options:
+  name:
+    description:
+      - name of the database to add or remove
+    required: true
+    default: null
+  login_user:
+    description:
+      - The username used to authenticate with
+    required: false
+    default: null
+  login_password:
+    description:
+      - The password used to authenticate with
+    required: false
+    default: null
+  login_host:
+    description:
+      - Host running the database
+    required: false
+    default: localhost
+  owner:
+    description:
+      - Name of the role to set as owner of the database
+    required: false
+    default: null
+  port:
+    description:
+      - Database port to connect to.
+    required: false
+    default: 5432
+  template:
+    description:
+      - Template used to create the database
+    required: false
+    default: null
+  encoding:
+    description:
+      - Encoding of the database
+    required: false
+    default: null
+  encoding:
+    description:
+      - Encoding of the database
+    required: false
+    default: null
+  lc_collate:
+    description:
+      - Collation order (LC_COLLATE) to use in the database. Must match collation order of template database unless C(template0) is used as template.
+    required: false
+    default: null
+  lc_ctype:
+    description:
+      - Character classification (LC_CTYPE) to use in the database (e.g. lower, upper, ...) Must match LC_CTYPE of template database unless C(template0) is used as template.
+    required: false
+    default: null
+  state:
+    description:
+      - The database state
+    required: false
+    default: present
+    choices: [ "present", "absent" ]
+notes:
+   - The default authentication assumes that you are either logging in as or sudo'ing to the C(postgres) account on the host.
+   - This module uses I(psycopg2), a Python PostgreSQL database adapter. You must ensure that psycopg2 is installed on
+     the host before using this module. If the remote host is the PostgreSQL server (which is the default case), then PostgreSQL must also be installed on the remote host. For Ubuntu-based systems, install the C(postgresql), C(libpq-dev), and C(python-psycopg2) packages on the remote host before using this module.
+requirements: [ psycopg2 ]
+author: Lorin Hochstein
+'''
+
+EXAMPLES = '''
+# Create a new database with name "acme"
+- postgresql_db: name=acme
+
+# Create a new database with name "acme" and specific encoding and locale
+# settings. If a template different from "template0" is specified, encoding
+# and locale settings must match those of the template.
+- postgresql_db: name=acme
+                 encoding='UTF-8'
+                 lc_collate='de_DE.UTF-8'
+                 lc_ctype='de_DE.UTF-8'
+                 template='template0'
+'''
+
+try:
+    import psycopg2
+    import psycopg2.extras
+except ImportError:
+    postgresqldb_found = False
+else:
+    postgresqldb_found = True
+
+class NotSupportedError(Exception):
+    pass
+
+
+# ===========================================
+# PostgreSQL module specific support methods.
+#
+
+def set_owner(cursor, db, owner):
+    query = "ALTER DATABASE \"%s\" OWNER TO \"%s\"" % (db, owner)
+    cursor.execute(query)
+    return True
+
+def get_encoding_id(cursor, encoding):
+    query = "SELECT pg_char_to_encoding(%(encoding)s) AS encoding_id;"
+    cursor.execute(query, {'encoding': encoding})
+    return cursor.fetchone()['encoding_id']
+
+def get_db_info(cursor, db):
+    query = """
+    SELECT rolname AS owner,
+    pg_encoding_to_char(encoding) AS encoding, encoding AS encoding_id,
+    datcollate AS lc_collate, datctype AS lc_ctype
+    FROM pg_database JOIN pg_roles ON pg_roles.oid = pg_database.datdba
+    WHERE datname = %(db)s
+    """
+    cursor.execute(query, {'db':db})
+    return cursor.fetchone()
+
+def db_exists(cursor, db):
+    query = "SELECT * FROM pg_database WHERE datname=%(db)s"
+    cursor.execute(query, {'db': db})
+    return cursor.rowcount == 1
+
+def db_delete(cursor, db):
+    if db_exists(cursor, db):
+        query = "DROP DATABASE \"%s\"" % db
+        cursor.execute(query)
+        return True
+    else:
+        return False
+
+def db_create(cursor, db, owner, template, encoding, lc_collate, lc_ctype):
+    if not db_exists(cursor, db):
+        if owner:
+            owner = " OWNER \"%s\"" % owner
+        if template:
+            template = " TEMPLATE \"%s\"" % template
+        if encoding:
+            encoding = " ENCODING '%s'" % encoding
+        if lc_collate:
+            lc_collate = " LC_COLLATE '%s'" % lc_collate
+        if lc_ctype:
+            lc_ctype = " LC_CTYPE '%s'" % lc_ctype
+        query = 'CREATE DATABASE "%s"%s%s%s%s%s' % (db, owner,
+                                                    template, encoding,
+                                                    lc_collate, lc_ctype)
+        cursor.execute(query)
+        return True
+    else:
+        db_info = get_db_info(cursor, db)
+        if (encoding and 
+            get_encoding_id(cursor, encoding) != db_info['encoding_id']):
+            raise NotSupportedError(
+                'Changing database encoding is not supported. '
+                'Current encoding: %s' % db_info['encoding']
+            )
+        elif lc_collate and lc_collate != db_info['lc_collate']:
+            raise NotSupportedError(
+                'Changing LC_COLLATE is not supported. '
+                'Current LC_COLLATE: %s' % db_info['lc_collate']
+            )
+        elif lc_ctype and lc_ctype != db_info['lc_ctype']:
+            raise NotSupportedError(
+                'Changing LC_CTYPE is not supported.'
+                'Current LC_CTYPE: %s' % db_info['lc_ctype']
+            )
+        elif owner and owner != db_info['owner']:
+            return set_owner(cursor, db, owner)
+        else:
+            return False
+
+def db_matches(cursor, db, owner, template, encoding, lc_collate, lc_ctype):
+    if not db_exists(cursor, db):
+       return False
+    else:
+        db_info = get_db_info(cursor, db)
+        if (encoding and 
+            get_encoding_id(cursor, encoding) != db_info['encoding_id']):
+            return False
+        elif lc_collate and lc_collate != db_info['lc_collate']:
+            return False
+        elif lc_ctype and lc_ctype != db_info['lc_ctype']:
+            return False
+        elif owner and owner != db_info['owner']:
+            return False
+        else:
+            return True
+
+# ===========================================
+# Module execution.
+#
+
+def main():
+    module = AnsibleModule(
+        argument_spec=dict(
+            login_user=dict(default="postgres"),
+            login_password=dict(default=""),
+            login_host=dict(default=""),
+            port=dict(default="5432"),
+            db=dict(required=True, aliases=['name']),
+            owner=dict(default=""),
+            template=dict(default=""),
+            encoding=dict(default=""),
+            lc_collate=dict(default=""),
+            lc_ctype=dict(default=""),
+            state=dict(default="present", choices=["absent", "present"]),
+        ),
+        supports_check_mode = True
+    )
+
+    if not postgresqldb_found:
+        module.fail_json(msg="the python psycopg2 module is required")
+
+    db = module.params["db"]
+    port = module.params["port"]
+    owner = module.params["owner"]
+    template = module.params["template"]
+    encoding = module.params["encoding"]
+    lc_collate = module.params["lc_collate"]
+    lc_ctype = module.params["lc_ctype"]
+    state = module.params["state"]
+    changed = False
+
+    # To use defaults values, keyword arguments must be absent, so 
+    # check which values are empty and don't include in the **kw
+    # dictionary
+    params_map = {
+        "login_host":"host",
+        "login_user":"user",
+        "login_password":"password",
+        "port":"port"
+    }
+    kw = dict( (params_map[k], v) for (k, v) in module.params.iteritems() 
+              if k in params_map and v != '' )
+    try:
+        db_connection = psycopg2.connect(database="template1", **kw)
+        # Enable autocommit so we can create databases
+        if psycopg2.__version__ >= '2.4.2':
+            db_connection.autocommit = True
+        else:
+            db_connection.set_isolation_level(psycopg2
+                                              .extensions
+                                              .ISOLATION_LEVEL_AUTOCOMMIT)
+        cursor = db_connection.cursor(
+                cursor_factory=psycopg2.extras.DictCursor)
+    except Exception, e:
+        module.fail_json(msg="unable to connect to database: %s" % e)
+
+    try:
+        if module.check_mode:
+            if state == "absent":
+                changed = not db_exists(cursor, db)
+            elif state == "present":
+                changed = not db_matches(cursor, db, owner, template, encoding,
+                                         lc_collate, lc_ctype)
+            module.exit_json(changed=changed,db=db)
+
+        if state == "absent":
+            changed = db_delete(cursor, db)
+
+        elif state == "present":
+            changed = db_create(cursor, db, owner, template, encoding,
+                                lc_collate, lc_ctype)
+    except NotSupportedError, e:
+        module.fail_json(msg=str(e))
+    except Exception, e:
+        module.fail_json(msg="Database query failed: %s" % e)
+
+    module.exit_json(changed=changed, db=db)
+
+# import module snippets
+from ansible.module_utils.basic import *
+main()

lib/ansible/modules/database/postgresql_privs

@@ -0,0 +1,613 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# 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: postgresql_privs
+version_added: "1.2"
+short_description: Grant or revoke privileges on PostgreSQL database objects.
+description:
+  - Grant or revoke privileges on PostgreSQL database objects.
+  - This module is basically a wrapper around most of the functionality of
+    PostgreSQL's GRANT and REVOKE statements with detection of changes
+    (GRANT/REVOKE I(privs) ON I(type) I(objs) TO/FROM I(roles))
+options:
+  database:
+    description:
+      - Name of database to connect to. 
+      - 'Alias: I(db)'
+    required: yes
+  state:
+    description:
+      - If C(present), the specified privileges are granted, if C(absent) they
+        are revoked.
+    required: no
+    default: present
+    choices: [present, absent]
+  privs:
+    description:
+      - Comma separated list of privileges to grant/revoke.
+      - 'Alias: I(priv)'
+    required: no
+  type:
+    description:
+      - Type of database object to set privileges on.
+    required: no
+    default: table
+    choices: [table, sequence, function, database,
+              schema, language, tablespace, group]
+  objs:
+    description:
+      - Comma separated list of database objects to set privileges on. 
+      - If I(type) is C(table) or C(sequence), the special value
+        C(ALL_IN_SCHEMA) can be provided instead to specify all database
+        objects of type I(type) in the schema specified via I(schema). (This
+        also works with PostgreSQL < 9.0.)
+      - If I(type) is C(database), this parameter can be omitted, in which case
+        privileges are set for the database specified via I(database).
+      - 'If I(type) is I(function), colons (":") in object names will be
+        replaced with commas (needed to specify function signatures, see
+        examples)'
+      - 'Alias: I(obj)'
+    required: no
+  schema:
+    description:
+      - Schema that contains the database objects specified via I(objs).
+      - May only be provided if I(type) is C(table), C(sequence) or
+        C(function). Defaults to  C(public) in these cases.
+    required: no
+  roles:
+    description:
+      - Comma separated list of role (user/group) names to set permissions for.
+      - The special value C(PUBLIC) can be provided instead to set permissions
+        for the implicitly defined PUBLIC group.
+      - 'Alias: I(role)'
+    required: yes
+  grant_option:
+    description:
+      - Whether C(role) may grant/revoke the specified privileges/group
+        memberships to others.
+      - Set to C(no) to revoke GRANT OPTION, leave unspecified to
+        make no changes.
+      - I(grant_option) only has an effect if I(state) is C(present).
+      - 'Alias: I(admin_option)'
+    required: no
+    choices: ['yes', 'no']
+  host:
+    description:
+      - Database host address. If unspecified, connect via Unix socket.
+      - 'Alias: I(login_host)'
+    default: null
+    required: no
+  port:
+    description:
+      - Database port to connect to.
+    required: no
+    default: 5432
+  login:
+    description:
+      - The username to authenticate with.
+      - 'Alias: I(login_user)'
+    default: postgres
+  password:
+    description:
+      - The password to authenticate with.
+      - 'Alias: I(login_password))'
+    default: null
+    required: no
+notes:
+  - Default authentication assumes that postgresql_privs is run by the
+    C(postgres) user on the remote host. (Ansible's C(user) or C(sudo-user)).
+  - This module requires Python package I(psycopg2) to be installed on the
+    remote host. In the default case of the remote host also being the
+    PostgreSQL server, PostgreSQL has to be installed there as well, obviously.
+    For Debian/Ubuntu-based systems, install packages I(postgresql) and
+    I(python-psycopg2).
+  - Parameters that accept comma separated lists (I(privs), I(objs), I(roles))
+    have singular alias names (I(priv), I(obj), I(role)).
+  - To revoke only C(GRANT OPTION) for a specific object, set I(state) to
+    C(present) and I(grant_option) to C(no) (see examples).
+  - Note that when revoking privileges from a role R, this role  may still have
+    access via privileges granted to any role R is a member of including
+    C(PUBLIC).
+  - Note that when revoking privileges from a role R, you do so as the user
+    specified via I(login). If R has been granted the same privileges by
+    another user also, R can still access database objects via these privileges.
+  - When revoking privileges, C(RESTRICT) is assumed (see PostgreSQL docs).
+requirements: [psycopg2]
+author: Bernhard Weitzhofer
+"""
+
+EXAMPLES = """
+# On database "library":
+# GRANT SELECT, INSERT, UPDATE ON TABLE public.books, public.authors 
+# TO librarian, reader WITH GRANT OPTION
+- postgresql_privs: >
+    database=library
+    state=present
+    privs=SELECT,INSERT,UPDATE
+    type=table
+    objs=books,authors
+    schema=public
+    roles=librarian,reader
+    grant_option=yes
+
+# Same as above leveraging default values:
+- postgresql_privs: >
+    db=library
+    privs=SELECT,INSERT,UPDATE
+    objs=books,authors
+    roles=librarian,reader
+    grant_option=yes
+
+# REVOKE GRANT OPTION FOR INSERT ON TABLE books FROM reader 
+# Note that role "reader" will be *granted* INSERT privilege itself if this 
+# isn't already the case (since state=present).
+- postgresql_privs: >
+    db=library
+    state=present
+    priv=INSERT
+    obj=books
+    role=reader
+    grant_option=no
+
+# REVOKE INSERT, UPDATE ON ALL TABLES IN SCHEMA public FROM reader
+# "public" is the default schema. This also works for PostgreSQL 8.x.
+- postgresql_privs: >
+    db=library
+    state=absent
+    privs=INSERT,UPDATE
+    objs=ALL_IN_SCHEMA
+    role=reader
+
+# GRANT ALL PRIVILEGES ON SCHEMA public, math TO librarian
+- postgresql_privs: >
+    db=library
+    privs=ALL
+    type=schema
+    objs=public,math
+    role=librarian
+
+# GRANT ALL PRIVILEGES ON FUNCTION math.add(int, int) TO librarian, reader
+# Note the separation of arguments with colons.
+- postgresql_privs: >
+    db=library
+    privs=ALL
+    type=function
+    obj=add(int:int)
+    schema=math
+    roles=librarian,reader
+
+# GRANT librarian, reader TO alice, bob WITH ADMIN OPTION
+# Note that group role memberships apply cluster-wide and therefore are not
+# restricted to database "library" here.
+- postgresql_privs: >
+    db=library
+    type=group
+    objs=librarian,reader
+    roles=alice,bob
+    admin_option=yes
+
+# GRANT ALL PRIVILEGES ON DATABASE library TO librarian
+# Note that here "db=postgres" specifies the database to connect to, not the
+# database to grant privileges on (which is specified via the "objs" param)
+- postgresql_privs: >
+    db=postgres
+    privs=ALL
+    type=database
+    obj=library
+    role=librarian
+
+# GRANT ALL PRIVILEGES ON DATABASE library TO librarian
+# If objs is omitted for type "database", it defaults to the database 
+# to which the connection is established
+- postgresql_privs: >
+    db=library
+    privs=ALL
+    type=database
+    role=librarian
+"""
+
+try:
+    import psycopg2
+    import psycopg2.extensions
+except ImportError:
+    psycopg2 = None
+
+
+class Error(Exception):
+    pass
+
+
+# We don't have functools.partial in Python < 2.5
+def partial(f, *args, **kwargs):
+    """Partial function application"""
+    def g(*g_args, **g_kwargs):
+        new_kwargs = kwargs.copy()
+        new_kwargs.update(g_kwargs)
+        return f(*(args + g_args), **g_kwargs)
+    g.f = f
+    g.args = args
+    g.kwargs = kwargs
+    return g
+
+
+class Connection(object):
+    """Wrapper around a psycopg2 connection with some convenience methods"""
+
+    def __init__(self, params):
+        self.database = params.database
+        # To use defaults values, keyword arguments must be absent, so
+        # check which values are empty and don't include in the **kw
+        # dictionary
+        params_map = {
+            "host":"host",
+            "login":"user",
+            "password":"password",
+            "port":"port",
+            "database": "database",
+        }
+        kw = dict( (params_map[k], getattr(params, k)) for k in params_map
+                   if getattr(params, k) != '' )
+        self.connection = psycopg2.connect(**kw)
+        self.cursor = self.connection.cursor()
+
+
+    def commit(self):
+        self.connection.commit()
+
+
+    def rollback(self):
+        self.connection.rollback()
+
+    @property
+    def encoding(self):
+        """Connection encoding in Python-compatible form"""
+        return psycopg2.extensions.encodings[self.connection.encoding]
+
+
+    ### Methods for querying database objects
+
+    # PostgreSQL < 9.0 doesn't support "ALL TABLES IN SCHEMA schema"-like
+    # phrases in GRANT or REVOKE statements, therefore alternative methods are
+    # provided here.
+
+    def schema_exists(self, schema):
+        query = """SELECT count(*)
+                   FROM pg_catalog.pg_namespace WHERE nspname = %s"""
+        self.cursor.execute(query, (schema,))
+        return self.cursor.fetchone()[0] > 0
+
+
+    def get_all_tables_in_schema(self, schema):
+        if not self.schema_exists(schema):
+            raise Error('Schema "%s" does not exist.' % schema)
+        query = """SELECT relname
+                   FROM pg_catalog.pg_class c
+                   JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+                   WHERE nspname = %s AND relkind = 'r'"""
+        self.cursor.execute(query, (schema,))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_all_sequences_in_schema(self, schema):
+        if not self.schema_exists(schema):
+            raise Error('Schema "%s" does not exist.' % schema)
+        query = """SELECT relname
+                   FROM pg_catalog.pg_class c
+                   JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+                   WHERE nspname = %s AND relkind = 'S'"""
+        self.cursor.execute(query, (schema,))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+
+    ### Methods for getting access control lists and group membership info
+
+    # To determine whether anything has changed after granting/revoking
+    # privileges, we compare the access control lists of the specified database
+    # objects before and afterwards. Python's list/string comparison should
+    # suffice for change detection, we should not actually have to parse ACLs.
+    # The same should apply to group membership information.
+
+    def get_table_acls(self, schema, tables):
+        query = """SELECT relacl
+                   FROM pg_catalog.pg_class c
+                   JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+                   WHERE nspname = %s AND relkind = 'r' AND relname = ANY (%s)
+                   ORDER BY relname"""
+        self.cursor.execute(query, (schema, tables))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_sequence_acls(self, schema, sequences):
+        query = """SELECT relacl
+                   FROM pg_catalog.pg_class c
+                   JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+                   WHERE nspname = %s AND relkind = 'S' AND relname = ANY (%s)
+                   ORDER BY relname"""
+        self.cursor.execute(query, (schema, sequences))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_function_acls(self, schema, function_signatures):
+        funcnames = [f.split('(', 1)[0] for f in function_signatures]
+        query = """SELECT proacl
+                   FROM pg_catalog.pg_proc p
+                   JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+                   WHERE nspname = %s AND proname = ANY (%s)
+                   ORDER BY proname, proargtypes"""
+        self.cursor.execute(query, (schema, funcnames))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_schema_acls(self, schemas):
+        query = """SELECT nspacl FROM pg_catalog.pg_namespace
+                   WHERE nspname = ANY (%s) ORDER BY nspname"""
+        self.cursor.execute(query, (schemas,))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_language_acls(self, languages):
+        query = """SELECT lanacl FROM pg_catalog.pg_language
+                   WHERE lanname = ANY (%s) ORDER BY lanname"""
+        self.cursor.execute(query, (languages,))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_tablespace_acls(self, tablespaces):
+        query = """SELECT spcacl FROM pg_catalog.pg_tablespace
+                   WHERE spcname = ANY (%s) ORDER BY spcname"""
+        self.cursor.execute(query, (tablespaces,))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_database_acls(self, databases):
+        query = """SELECT datacl FROM pg_catalog.pg_database
+                   WHERE datname = ANY (%s) ORDER BY datname"""
+        self.cursor.execute(query, (databases,))
+        return [t[0] for t in self.cursor.fetchall()]
+
+
+    def get_group_memberships(self, groups):
+        query = """SELECT roleid, grantor, member, admin_option
+                   FROM pg_catalog.pg_auth_members am 
+                   JOIN pg_catalog.pg_roles r ON r.oid = am.roleid
+                   WHERE r.rolname = ANY(%s) 
+                   ORDER BY roleid, grantor, member"""
+        self.cursor.execute(query, (groups,))
+        return self.cursor.fetchall()
+
+
+    ### Manipulating privileges
+
+    def manipulate_privs(self, obj_type, privs, objs, roles,
+                         state, grant_option, schema_qualifier=None):
+        """Manipulate database object privileges.
+
+        :param obj_type: Type of database object to grant/revoke
+                         privileges for.
+        :param privs: Either a list of privileges to grant/revoke 
+                      or None if type is "group".
+        :param objs: List of database objects to grant/revoke
+                     privileges for.
+        :param roles: Either a list of role names or "PUBLIC"
+                      for the implicitly defined "PUBLIC" group
+        :param state: "present" to grant privileges, "absent" to revoke.
+        :param grant_option: Only for state "present": If True, set 
+                             grant/admin option. If False, revoke it.
+                             If None, don't change grant option.
+        :param schema_qualifier: Some object types ("TABLE", "SEQUENCE",
+                                 "FUNCTION") must be qualified by schema.
+                                 Ignored for other Types.
+        """
+        # get_status: function to get current status
+        if obj_type == 'table':
+            get_status = partial(self.get_table_acls, schema_qualifier)
+        elif obj_type == 'sequence':
+            get_status = partial(self.get_sequence_acls, schema_qualifier)
+        elif obj_type == 'function':
+            get_status = partial(self.get_function_acls, schema_qualifier)
+        elif obj_type == 'schema':
+            get_status = self.get_schema_acls
+        elif obj_type == 'language':
+            get_status = self.get_language_acls
+        elif obj_type == 'tablespace':
+            get_status = self.get_tablespace_acls
+        elif obj_type == 'database':
+            get_status = self.get_database_acls
+        elif obj_type == 'group':
+            get_status = self.get_group_memberships
+        else:
+            raise Error('Unsupported database object type "%s".' % obj_type)
+
+        # Return False (nothing has changed) if there are no objs to work on.
+        if not objs:
+            return False
+
+        # obj_ids: quoted db object identifiers (sometimes schema-qualified)
+        if obj_type == 'function':
+            obj_ids = []
+            for obj in objs:
+                try:
+                    f, args = obj.split('(', 1)
+                except:
+                    raise Error('Illegal function signature: "%s".' % obj)
+                obj_ids.append('"%s"."%s"(%s' % (schema_qualifier, f, args))
+        elif obj_type in ['table', 'sequence']:
+            obj_ids = ['"%s"."%s"' % (schema_qualifier, o) for o in objs]
+        else:
+            obj_ids = ['"%s"' % o for o in objs]
+
+        # set_what: SQL-fragment specifying what to set for the target roless:
+        # Either group membership or privileges on objects of a certain type.
+        if obj_type == 'group':
+            set_what = ','.join(obj_ids)
+        else:
+            set_what = '%s ON %s %s' % (','.join(privs), obj_type, 
+                                        ','.join(obj_ids))
+
+        # for_whom: SQL-fragment specifying for whom to set the above
+        if roles == 'PUBLIC':
+            for_whom = 'PUBLIC'
+        else:
+            for_whom = ','.join(['"%s"' % r for r in roles])
+
+        status_before = get_status(objs)
+        if state == 'present':
+            if grant_option:
+                if obj_type == 'group':
+                    query = 'GRANT %s TO %s WITH ADMIN OPTION'
+                else:
+                    query = 'GRANT %s TO %s WITH GRANT OPTION'
+            else:
+                query = 'GRANT %s TO %s' 
+            self.cursor.execute(query % (set_what, for_whom))
+
+            # Only revoke GRANT/ADMIN OPTION if grant_option actually is False.
+            if grant_option == False:
+                if obj_type == 'group':
+                    query = 'REVOKE ADMIN OPTION FOR %s FROM %s'
+                else:
+                    query = 'REVOKE GRANT OPTION FOR %s FROM %s'
+                self.cursor.execute(query % (set_what, for_whom))
+        else:
+            query = 'REVOKE %s FROM %s' 
+            self.cursor.execute(query % (set_what, for_whom))
+        status_after = get_status(objs)
+        return status_before != status_after
+
+
+def main():
+    module = AnsibleModule(
+        argument_spec = dict(
+            database=dict(required=True, aliases=['db']),
+            state=dict(default='present', choices=['present', 'absent']),
+            privs=dict(required=False, aliases=['priv']),
+            type=dict(default='table',
+                      choices=['table',
+                               'sequence',
+                               'function',
+                               'database',
+                               'schema',
+                               'language',
+                               'tablespace',
+                               'group']),
+            objs=dict(required=False, aliases=['obj']),
+            schema=dict(required=False),
+            roles=dict(required=True, aliases=['role']),
+            grant_option=dict(required=False, type='bool', 
+                              aliases=['admin_option']),
+            host=dict(default='', aliases=['login_host']),
+            port=dict(type='int', default=5432),
+            login=dict(default='postgres', aliases=['login_user']),
+            password=dict(default='', aliases=['login_password'])
+        ),
+        supports_check_mode = True
+    )
+
+    # Create type object as namespace for module params
+    p = type('Params', (), module.params)
+
+    # param "schema": default, allowed depends on param "type"
+    if p.type in ['table', 'sequence', 'function']:
+        p.schema = p.schema or 'public'
+    elif p.schema:
+        module.fail_json(msg='Argument "schema" is not allowed '
+                             'for type "%s".' % p.type)
+
+    # param "objs": default, required depends on param "type"
+    if p.type == 'database':
+        p.objs = p.objs or p.database
+    elif not p.objs:
+        module.fail_json(msg='Argument "objs" is required '
+                             'for type "%s".' % p.type)
+
+    # param "privs": allowed, required depends on param "type"
+    if p.type == 'group':
+        if p.privs:
+            module.fail_json(msg='Argument "privs" is not allowed '
+                                 'for type "group".')
+    elif not p.privs:
+        module.fail_json(msg='Argument "privs" is required '
+                             'for type "%s".' % p.type)
+
+    # Connect to Database
+    if not psycopg2:
+        module.fail_json(msg='Python module "psycopg2" must be installed.')
+    try:
+        conn = Connection(p)
+    except psycopg2.Error, e:
+        module.fail_json(msg='Could not connect to database: %s' % e)
+
+    try:
+        # privs
+        if p.privs:
+            privs = p.privs.split(',')
+        else:
+            privs = None
+
+        # objs:
+        if p.type == 'table' and p.objs == 'ALL_IN_SCHEMA':
+            objs = conn.get_all_tables_in_schema(p.schema)
+        elif p.type == 'sequence' and p.objs == 'ALL_IN_SCHEMA':
+            objs = conn.get_all_sequences_in_schema(p.schema)
+        else:
+            objs = p.objs.split(',')
+
+        # function signatures are encoded using ':' to separate args
+        if p.type == 'function':
+            objs = [obj.replace(':', ',') for obj in objs]
+
+        # roles
+        if p.roles == 'PUBLIC':
+            roles = 'PUBLIC'
+        else:
+            roles = p.roles.split(',')
+
+        changed = conn.manipulate_privs(
+            obj_type = p.type,
+            privs = privs,
+            objs = objs,
+            roles = roles,
+            state = p.state,
+            grant_option = p.grant_option,
+            schema_qualifier=p.schema
+        )
+
+    except Error, e:
+        conn.rollback()
+        module.fail_json(msg=e.message)
+
+    except psycopg2.Error, e:
+        conn.rollback()
+        # psycopg2 errors come in connection encoding, reencode
+        msg = e.message.decode(conn.encoding).encode(sys.getdefaultencoding(),
+                                                     'replace')
+        module.fail_json(msg=msg)
+
+    if module.check_mode:
+        conn.rollback()
+    else:
+        conn.commit()
+    module.exit_json(changed=changed)
+
+
+# import module snippets
+from ansible.module_utils.basic import *
+main()

lib/ansible/modules/database/postgresql_user

@@ -0,0 +1,526 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# 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: postgresql_user
+short_description: Adds or removes a users (roles) from a PostgreSQL database.
+description:
+   - Add or remove PostgreSQL users (roles) from a remote host and, optionally,
+     grant the users access to an existing database or tables.
+   - The fundamental function of the module is to create, or delete, roles from
+     a PostgreSQL cluster. Privilege assignment, or removal, is an optional
+     step, which works on one database at a time. This allows for the module to
+     be called several times in the same module to modify the permissions on
+     different databases, or to grant permissions to already existing users.
+   - A user cannot be removed until all the privileges have been stripped from
+     the user. In such situation, if the module tries to remove the user it
+     will fail. To avoid this from happening the fail_on_user option signals
+     the module to try to remove the user, but if not possible keep going; the
+     module will report if changes happened and separately if the user was
+     removed or not.
+version_added: "0.6"
+options:
+  name:
+    description:
+      - name of the user (role) to add or remove
+    required: true
+    default: null
+  password:
+    description:
+      - set the user's password, before 1.4 this was required.
+      - "When passing an encrypted password, the encrypted parameter must also be true, and it must be generated with the format C('str[\\"md5\\"] + md5[ password + username ]'), resulting in a total of 35 characters.  An easy way to do this is: C(echo \\"md5`echo -n \\"verysecretpasswordJOE\\" | md5`\\")."
+    required: false
+    default: null
+  db:
+    description:
+      - name of database where permissions will be granted
+    required: false
+    default: null
+  fail_on_user:
+    description:
+      - if C(yes), fail when user can't be removed. Otherwise just log and continue
+    required: false
+    default: 'yes'
+    choices: [ "yes", "no" ]
+  port:
+    description:
+      - Database port to connect to.
+    required: false
+    default: 5432
+  login_user:
+    description:
+      - User (role) used to authenticate with PostgreSQL
+    required: false
+    default: postgres
+  login_password:
+    description:
+      - Password used to authenticate with PostgreSQL
+    required: false
+    default: null
+  login_host:
+    description:
+      - Host running PostgreSQL.
+    required: false
+    default: localhost
+  priv:
+    description:
+      - "PostgreSQL privileges string in the format: C(table:priv1,priv2)"
+    required: false
+    default: null
+  role_attr_flags:
+    description:
+      - "PostgreSQL role attributes string in the format: CREATEDB,CREATEROLE,SUPERUSER"
+    required: false
+    default: null
+    choices: [ "[NO]SUPERUSER","[NO]CREATEROLE", "[NO]CREATEUSER", "[NO]CREATEDB",
+                    "[NO]INHERIT", "[NO]LOGIN", "[NO]REPLICATION" ]
+  state:
+    description:
+      - The user (role) state
+    required: false
+    default: present
+    choices: [ "present", "absent" ]
+  encrypted:
+    description:
+      - denotes if the password is already encrypted. boolean.
+    required: false
+    default: false
+    version_added: '1.4'
+  expires:
+    description:
+      - sets the user's password expiration.
+    required: false
+    default: null
+    version_added: '1.4'
+notes:
+   - The default authentication assumes that you are either logging in as or
+     sudo'ing to the postgres account on the host.
+   - This module uses psycopg2, a Python PostgreSQL database adapter. You must
+     ensure that psycopg2 is installed on the host before using this module. If
+     the remote host is the PostgreSQL server (which is the default case), then
+     PostgreSQL must also be installed on the remote host. For Ubuntu-based
+     systems, install the postgresql, libpq-dev, and python-psycopg2 packages
+     on the remote host before using this module.
+   - If you specify PUBLIC as the user, then the privilege changes will apply
+     to all users. You may not specify password or role_attr_flags when the
+     PUBLIC user is specified.
+requirements: [ psycopg2 ]
+author: Lorin Hochstein
+'''
+
+EXAMPLES = '''
+# Create django user and grant access to database and products table
+- postgresql_user: db=acme name=django password=ceec4eif7ya priv=CONNECT/products:ALL
+
+# Create rails user, grant privilege to create other databases and demote rails from super user status
+- postgresql_user: name=rails password=secret role_attr_flags=CREATEDB,NOSUPERUSER
+
+# Remove test user privileges from acme
+- postgresql_user: db=acme name=test priv=ALL/products:ALL state=absent fail_on_user=no
+
+# Remove test user from test database and the cluster
+- postgresql_user: db=test name=test priv=ALL state=absent
+
+# Example privileges string format
+INSERT,UPDATE/table:SELECT/anothertable:ALL
+
+# Remove an existing user's password
+- postgresql_user: db=test user=test password=NULL
+'''
+
+import re
+
+try:
+    import psycopg2
+except ImportError:
+    postgresqldb_found = False
+else:
+    postgresqldb_found = True
+
+# ===========================================
+# PostgreSQL module specific support methods.
+#
+
+
+def user_exists(cursor, user):
+    # The PUBLIC user is a special case that is always there
+    if user == 'PUBLIC':
+        return True
+    query = "SELECT rolname FROM pg_roles WHERE rolname=%(user)s"
+    cursor.execute(query, {'user': user})
+    return cursor.rowcount > 0
+
+
+def user_add(cursor, user, password, role_attr_flags,  encrypted, expires):
+    """Create a new database user (role)."""
+    query_password_data = dict()
+    query = 'CREATE USER "%(user)s"' % { "user": user}
+    if password is not None:
+        query = query + " WITH %(crypt)s" % { "crypt": encrypted }
+        query = query + " PASSWORD %(password)s"
+        query_password_data.update(password=password)
+    if expires is not None:
+        query = query + " VALID UNTIL '%(expires)s'" % { "expires": expires }
+    query = query + " " + role_attr_flags
+    cursor.execute(query, query_password_data)
+    return True
+
+def user_alter(cursor, module, user, password, role_attr_flags, encrypted, expires):
+    """Change user password and/or attributes. Return True if changed, False otherwise."""
+    changed = False
+
+    if user == 'PUBLIC':
+        if password is not None:
+            module.fail_json(msg="cannot change the password for PUBLIC user")
+        elif role_attr_flags != '':
+            module.fail_json(msg="cannot change the role_attr_flags for PUBLIC user")
+        else:
+            return False
+
+    # Handle passwords.
+    if password is not None or role_attr_flags is not None:
+        # Select password and all flag-like columns in order to verify changes.
+        query_password_data = dict()
+        select = "SELECT * FROM pg_authid where rolname=%(user)s"
+        cursor.execute(select, {"user": user})
+        # Grab current role attributes.
+        current_role_attrs = cursor.fetchone()
+
+        alter = 'ALTER USER "%(user)s"' % {"user": user}
+        if password is not None:
+            query_password_data.update(password=password)
+            alter = alter + " WITH %(crypt)s" % {"crypt": encrypted}
+            alter = alter + " PASSWORD %(password)s"
+            alter = alter + "  %(flags)s" % {'flags': role_attr_flags}
+        elif role_attr_flags:
+            alter = alter + ' WITH ' + role_attr_flags
+        if expires is not None:
+            alter = alter + " VALID UNTIL '%(expires)s'" % { "exipres": expires }
+
+        try:
+            cursor.execute(alter, query_password_data)
+        except psycopg2.InternalError, e:
+            if e.pgcode == '25006':
+                # Handle errors due to read-only transactions indicated by pgcode 25006
+                # ERROR:  cannot execute ALTER ROLE in a read-only transaction
+                changed = False
+                module.fail_json(msg=e.pgerror)
+                return changed
+            else:
+                raise psycopg2.InternalError, e
+
+        # Grab new role attributes.
+        cursor.execute(select, {"user": user})
+        new_role_attrs = cursor.fetchone()
+
+        # Detect any differences between current_ and new_role_attrs.
+        for i in range(len(current_role_attrs)):
+            if current_role_attrs[i] != new_role_attrs[i]:
+                changed = True
+
+    return changed
+
+def user_delete(cursor, user):
+    """Try to remove a user. Returns True if successful otherwise False"""
+    cursor.execute("SAVEPOINT ansible_pgsql_user_delete")
+    try:
+        cursor.execute("DROP USER \"%s\"" % user)
+    except:
+        cursor.execute("ROLLBACK TO SAVEPOINT ansible_pgsql_user_delete")
+        cursor.execute("RELEASE SAVEPOINT ansible_pgsql_user_delete")
+        return False
+
+    cursor.execute("RELEASE SAVEPOINT ansible_pgsql_user_delete")
+    return True
+
+def has_table_privilege(cursor, user, table, priv):
+    query = 'SELECT has_table_privilege(%s, %s, %s)'
+    cursor.execute(query, (user, table, priv))
+    return cursor.fetchone()[0]
+
+def get_table_privileges(cursor, user, table):
+    if '.' in table:
+        schema, table = table.split('.', 1)
+    else:
+        schema = 'public'
+    query = '''SELECT privilege_type FROM information_schema.role_table_grants
+    WHERE grantee=%s AND table_name=%s AND table_schema=%s'''
+    cursor.execute(query, (user, table, schema))
+    return set([x[0] for x in cursor.fetchall()])
+
+
+def quote_pg_identifier(identifier):
+    """
+    quote postgresql identifiers involving zero or more namespaces
+    """
+
+    if '"' in identifier:
+        # the user has supplied their own quoting. we have to hope they're
+        # doing it right.  Maybe they have an unfortunately named table
+        # containing a period in the name, such as: "public"."users.2013"
+        return identifier
+
+    tokens = identifier.strip().split(".")
+    quoted_tokens = []
+    for token in tokens:
+        quoted_tokens.append('"%s"' % (token, ))
+    return ".".join(quoted_tokens)
+
+def grant_table_privilege(cursor, user, table, priv):
+    prev_priv = get_table_privileges(cursor, user, table)
+    query = 'GRANT %s ON TABLE %s TO %s' % (
+        priv, quote_pg_identifier(table), quote_pg_identifier(user), )
+    cursor.execute(query)
+    curr_priv = get_table_privileges(cursor, user, table)
+    return len(curr_priv) > len(prev_priv)
+
+def revoke_table_privilege(cursor, user, table, priv):
+    prev_priv = get_table_privileges(cursor, user, table)
+    query = 'REVOKE %s ON TABLE %s FROM %s' % (
+        priv, quote_pg_identifier(table), quote_pg_identifier(user), )
+    cursor.execute(query)
+    curr_priv = get_table_privileges(cursor, user, table)
+    return len(curr_priv) < len(prev_priv)
+
+
+def get_database_privileges(cursor, user, db):
+    priv_map = {
+        'C':'CREATE',
+        'T':'TEMPORARY',
+        'c':'CONNECT',
+    }
+    query = 'SELECT datacl FROM pg_database WHERE datname = %s'
+    cursor.execute(query, (db,))
+    datacl = cursor.fetchone()[0]
+    if datacl is None:
+        return []
+    r = re.search('%s=(C?T?c?)/[a-z]+\,?' % user, datacl)
+    if r is None:
+        return []
+    o = []
+    for v in r.group(1):
+        o.append(priv_map[v])
+    return o
+
+def has_database_privilege(cursor, user, db, priv):
+    query = 'SELECT has_database_privilege(%s, %s, %s)'
+    cursor.execute(query, (user, db, priv))
+    return cursor.fetchone()[0]
+
+def grant_database_privilege(cursor, user, db, priv):
+    prev_priv = get_database_privileges(cursor, user, db)
+    if user == "PUBLIC":
+        query = 'GRANT %s ON DATABASE \"%s\" TO PUBLIC' % (priv, db)
+    else:
+        query = 'GRANT %s ON DATABASE \"%s\" TO \"%s\"' % (priv, db, user)
+    cursor.execute(query)
+    curr_priv = get_database_privileges(cursor, user, db)
+    return len(curr_priv) > len(prev_priv)
+
+def revoke_database_privilege(cursor, user, db, priv):
+    prev_priv = get_database_privileges(cursor, user, db)
+    if user == "PUBLIC":
+        query = 'REVOKE %s ON DATABASE \"%s\" FROM PUBLIC' % (priv, db)
+    else:
+        query = 'REVOKE %s ON DATABASE \"%s\" FROM \"%s\"' % (priv, db, user)
+    cursor.execute(query)
+    curr_priv = get_database_privileges(cursor, user, db)
+    return len(curr_priv) < len(prev_priv)
+
+def revoke_privileges(cursor, user, privs):
+    if privs is None:
+        return False
+
+    changed = False
+    for type_ in privs:
+        revoke_func = {
+            'table':revoke_table_privilege,
+            'database':revoke_database_privilege
+        }[type_]
+        for name, privileges in privs[type_].iteritems():
+            for privilege in privileges:
+                changed = revoke_func(cursor, user, name, privilege)\
+                        or changed
+
+    return changed
+
+def grant_privileges(cursor, user, privs):
+    if privs is None:
+        return False
+
+    changed = False
+    for type_ in privs:
+        grant_func = {
+            'table':grant_table_privilege,
+            'database':grant_database_privilege
+        }[type_]
+        for name, privileges in privs[type_].iteritems():
+            for privilege in privileges:
+                changed = grant_func(cursor, user, name, privilege)\
+                        or changed
+
+    return changed
+
+def parse_role_attrs(role_attr_flags):
+    """
+    Parse role attributes string for user creation.
+    Format:
+
+        attributes[,attributes,...]
+
+    Where:
+
+        attributes := CREATEDB,CREATEROLE,NOSUPERUSER,...
+    """
+    if ',' not in role_attr_flags:
+        return role_attr_flags
+    flag_set = role_attr_flags.split(",")
+    o_flags = " ".join(flag_set)
+    return o_flags
+
+def parse_privs(privs, db):
+    """
+    Parse privilege string to determine permissions for database db.
+    Format:
+
+        privileges[/privileges/...]
+
+    Where:
+
+        privileges := DATABASE_PRIVILEGES[,DATABASE_PRIVILEGES,...] |
+            TABLE_NAME:TABLE_PRIVILEGES[,TABLE_PRIVILEGES,...]
+    """
+    if privs is None:
+        return privs
+
+    o_privs = {
+        'database':{},
+        'table':{}
+    }
+    for token in privs.split('/'):
+        if ':' not in token:
+            type_ = 'database'
+            name = db
+            priv_set = set(x.strip() for x in token.split(','))
+        else:
+            type_ = 'table'
+            name, privileges = token.split(':', 1)
+            priv_set = set(x.strip() for x in privileges.split(','))
+
+        o_privs[type_][name] = priv_set
+
+    return o_privs
+
+# ===========================================
+# Module execution.
+#
+
+def main():
+    module = AnsibleModule(
+        argument_spec=dict(
+            login_user=dict(default="postgres"),
+            login_password=dict(default=""),
+            login_host=dict(default=""),
+            user=dict(required=True, aliases=['name']),
+            password=dict(default=None),
+            state=dict(default="present", choices=["absent", "present"]),
+            priv=dict(default=None),
+            db=dict(default=''),
+            port=dict(default='5432'),
+            fail_on_user=dict(type='bool', default='yes'),
+            role_attr_flags=dict(default=''),
+            encrypted=dict(type='bool', default='no'),
+            expires=dict(default=None)
+        ),
+        supports_check_mode = True
+    )
+
+    user = module.params["user"]
+    password = module.params["password"]
+    state = module.params["state"]
+    fail_on_user = module.params["fail_on_user"]
+    db = module.params["db"]
+    if db == '' and module.params["priv"] is not None:
+        module.fail_json(msg="privileges require a database to be specified")
+    privs = parse_privs(module.params["priv"], db)
+    port = module.params["port"]
+    role_attr_flags = parse_role_attrs(module.params["role_attr_flags"])
+    if module.params["encrypted"]:
+        encrypted = "ENCRYPTED"
+    else:
+        encrypted = "UNENCRYPTED"
+    expires = module.params["expires"]
+
+    if not postgresqldb_found:
+        module.fail_json(msg="the python psycopg2 module is required")
+
+    # To use defaults values, keyword arguments must be absent, so
+    # check which values are empty and don't include in the **kw
+    # dictionary
+    params_map = {
+        "login_host":"host",
+        "login_user":"user",
+        "login_password":"password",
+        "port":"port",
+        "db":"database"
+    }
+    kw = dict( (params_map[k], v) for (k, v) in module.params.iteritems()
+              if k in params_map and v != "" )
+    try:
+        db_connection = psycopg2.connect(**kw)
+        cursor = db_connection.cursor()
+    except Exception, e:
+        module.fail_json(msg="unable to connect to database: %s" % e)
+
+    kw = dict(user=user)
+    changed = False
+    user_removed = False
+
+    if state == "present":
+        if user_exists(cursor, user):
+            changed = user_alter(cursor, module, user, password, role_attr_flags, encrypted, expires)
+        else:
+            changed = user_add(cursor, user, password, role_attr_flags, encrypted, expires)
+        changed = grant_privileges(cursor, user, privs) or changed
+    else:
+        if user_exists(cursor, user):
+            if  module.check_mode:
+                changed = True
+                kw['user_removed'] = True
+            else:
+                changed = revoke_privileges(cursor, user, privs)
+                user_removed = user_delete(cursor, user)
+                changed = changed or user_removed
+                if fail_on_user and not user_removed:
+                    msg = "unable to remove user"
+                    module.fail_json(msg=msg)
+                kw['user_removed'] = user_removed
+
+    if changed:
+        if module.check_mode:
+            db_connection.rollback()
+        else:
+            db_connection.commit()
+
+    kw['changed'] = changed
+    module.exit_json(**kw)
+
+# import module snippets
+from ansible.module_utils.basic import *
+main()