Merge pull request #46 from ckotte/pkgbuild

Add pkgbuild option to build local package

README.md

@@ -17,8 +17,10 @@ The following helpers are supported and automatically selected, if present, in t
 |name           |                                                       |Name or list of names of the package(s) to install or upgrade.|
 |state          |**present**, latest                                    |Desired state of the package, 'present' skips operations if the package is already installed.|
 |upgrade        |yes, **no**                                            |Whether or not to upgrade whole system.|
-|use            |**auto**, yay, pacaur, trizen, pikaur, aurman, makepkg |The helper to use, 'auto' uses the first known helper found and makepkg as a fallback.|
+|use            |**auto**, yay, pacaur, trizen, pikaur, aurman, makepkg |The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.|
+|extra_args     |**null**                                               |A list of additional arguments to pass directly to the tool. Cannot be used in 'auto' mode.|
 |aur_only       |yes, **no**                                            |Limit helper operation to the AUR.|
+|local_pkgbuild |Local directory with PKGBUILD, **null**                |Only valid with makepkg or pikaur. Don't download the package from AUR. Build the package using a local PKGBUILD and the other build files.|
 |skip_pgp_check |yes, **no**                                            |Only valid with makepkg. Skip PGP signatures verification of source file, useful when installing packages without GnuPG properly configured.|
 |ignore_arch    |yes, **no**                                            |Only valid with makepkg. Ignore a missing or incomplete arch field, useful when the PKGBUILD does not have the arch=('yourarch') field.|
 
@@ -29,7 +31,8 @@ The following helpers are supported and automatically selected, if present, in t
 ## Installing
 ### AUR package
 The [ansible-aur-git](https://aur.archlinux.org/packages/ansible-aur-git) package is available in the AUR.
-Note the module is installed in `/usr/share/ansible/plugins/modules` which is one of the default module library paths.
+
+Note: The module is installed in `/usr/share/ansible/plugins/modules` which is one of the default module library paths.
 
 ### Manual installation
 Just clone the *ansible-aur* repository into your user custom-module directory:
@@ -43,7 +46,7 @@ git clone https://github.com/kewlfft/ansible-aur.git ~/.ansible/plugins/modules/
 ansible-galaxy install kewlfft.aur
 ```
 
-Note that if this module is installed from Ansible Galaxy, you will need to list it explicitly in your playbook:
+Note: If this module is installed from Ansible Galaxy, you will need to list it explicitly in your playbook:
 ```
 # playbook.yml
 - hosts: localhost
@@ -105,6 +108,17 @@ Use it in a task, as in the following examples:
       - package_name_1
       - package_name_2
 
-# Upgrade the system using yay, only act on AUR packages, note that dependency resolving will still include repository packages
+# Upgrade the system using yay, only act on AUR packages.
+# Note: Dependency resolving will still include repository packages.
 - aur: upgrade=yes use=yay aur_only=yes
+
+# Install gnome-shell-extension-caffeine-git using pikaur and a local PKGBUILD.
+# Skip if it is already installed
+- aur:
+    name: gnome-shell-extension-caffeine-git
+    use: pikaur
+    local_pkgbuild: {{ role_path }}/files/gnome-shell-extension-caffeine-git
+    state: present
+  become: yes
+  become_user: aur_builder
 ```

library/aur.py

@@ -2,12 +2,14 @@
 
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-from ansible.module_utils.basic import *
+from ansible.module_utils.basic import AnsibleModule
 from ansible.module_utils.urls import open_url
 import json
+import shlex
 import tarfile
 import os
 import os.path
+import shutil
 import tempfile
 import urllib.parse
 
@@ -34,20 +36,27 @@ options:
     upgrade:
         description:
             - Whether or not to upgrade whole system.
-        type: bool
         default: no
+        type: bool
 
     use:
         description:
-            - The helper to use, 'auto' uses the first known helper found and makepkg as a fallback.
+            - The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.
         default: auto
         choices: [ auto, yay, pacaur, trizen, pikaur, aurman, makepkg ]
 
+    extra_args:
+        description:
+            - Arguments to pass to the tool.
+              Requires that the 'use' option be set to something other than 'auto'.
+        type: str
+
     skip_pgp_check:
         description:
             - Only valid with makepkg.
               Skip PGP signatures verification of source file.
               This is useful when installing packages without GnuPG (properly) configured.
+              Cannot be used unless use is set to 'makepkg'.
         type: bool
         default: no
 
@@ -55,12 +64,23 @@ options:
         description:
             - Only valid with makepkg.
               Ignore a missing or incomplete arch field, useful when the PKGBUILD does not have the arch=('yourarch') field.
+              Cannot be used unless use is set to 'makepkg'.
         type: bool
         default: no
 
     aur_only:
         description:
             - Limit helper operation to the AUR.
+        type: bool
+        default: no
+
+    local_pkgbuild:
+        description:
+            - Only valid with makepkg or pikaur.
+              Directory with PKGBUILD and build files.
+              Cannot be used unless use is set to 'makepkg' or 'pikaur'.
+        type: path
+        default: no
 notes:
   - When used with a `loop:` each package will be processed individually,
     it is much more efficient to pass the list directly to the `name` option.
@@ -80,7 +100,6 @@ EXAMPLES = '''
   become_user: aur_builder
 '''
 
-
 def_lang = ['env', 'LC_ALL=C']
 
 use_cmd = {
@@ -92,6 +111,11 @@ use_cmd = {
     'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
 }
 
+use_cmd_local_pkgbuild = {
+    'pikaur': ['pikaur', '-P', '--noconfirm', '--noedit', '--needed', '--install'],
+    'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
+}
+
 has_aur_option = ['yay', 'pacaur', 'trizen', 'pikaur', 'aurman']
 
 
@@ -135,10 +159,32 @@ def check_packages(module, packages):
     module.exit_json(changed=status, msg=message, diff=diff)
 
 
-def install_with_makepkg(module, package):
+def build_command_prefix(use, extra_args, skip_pgp_check=False, ignore_arch=False, aur_only=False, local_pkgbuild=None):
     """
-    Install the specified package with makepkg
+    Create the prefix of a command that can be used by the install and upgrade functions.
     """
+    if local_pkgbuild:
+        command = def_lang + use_cmd_local_pkgbuild[use]
+    else:
+        command = def_lang + use_cmd[use]
+    if skip_pgp_check:
+        command.append('--skippgpcheck')
+    if ignore_arch:
+        command.append('--ignorearch')
+    if aur_only and use in has_aur_option:
+        command.append('--aur')
+    if local_pkgbuild and use != 'makepkg':
+        command.append(local_pkgbuild)
+    if extra_args:
+        command += shlex.split(extra_args)
+    return command
+
+
+def install_with_makepkg(module, package, extra_args, skip_pgp_check, ignore_arch, local_pkgbuild=None):
+    """
+    Install the specified package or a local PKGBUILD with makepkg
+    """
+    if not local_pkgbuild:
         module.get_bin_path('fakeroot', required=True)
         f = open_url('https://aur.archlinux.org/rpc/?v=5&type=info&arg={}'.format(urllib.parse.quote(package)))
         result = json.loads(f.read().decode('utf8'))
@@ -147,24 +193,54 @@ def install_with_makepkg(module, package):
         result = result['results'][0]
         f = open_url('https://aur.archlinux.org/{}'.format(result['URLPath']))
     with tempfile.TemporaryDirectory() as tmpdir:
+        if local_pkgbuild:
+            shutil.copytree(local_pkgbuild, tmpdir, dirs_exist_ok=True)
+            command = build_command_prefix('makepkg', extra_args)
+            rc, out, err = module.run_command(command, cwd=tmpdir, check_rc=True)
+        else:
             tar = tarfile.open(mode='r|*', fileobj=f)
             tar.extractall(tmpdir)
             tar.close()
-        if module.params['skip_pgp_check']:
+            command = build_command_prefix('makepkg', extra_args, skip_pgp_check=skip_pgp_check, ignore_arch=ignore_arch)
-            use_cmd['makepkg'].append('--skippgpcheck')
+            rc, out, err = module.run_command(command, cwd=os.path.join(tmpdir, result['Name']), check_rc=True)
-        if module.params['ignore_arch']:
-            use_cmd['makepkg'].append('--ignorearch')
-        rc, out, err = module.run_command(use_cmd['makepkg'], cwd=os.path.join(tmpdir, result['Name']), check_rc=True)
     return (rc, out, err)
 
 
-def upgrade(module, use, aur_only):
+def install_local_package(module, package, use, extra_args, local_pkgbuild):
+    """
+    Install the specified package with a local PKGBUILD
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        shutil.copytree(local_pkgbuild, tmpdir, dirs_exist_ok=True)
+        command = build_command_prefix(use, extra_args, local_pkgbuild=tmpdir + '/PKGBUILD')
+        rc, out, err = module.run_command(command, check_rc=True)
+    return (rc, out, err)
+
+
+def check_upgrade(module, use):
+    """
+    Inform user how many packages would be upgraded
+    """
+    rc, stdout, stderr = module.run_command([use, '-Qu'], check_rc=True)
+    data = stdout.split('\n')
+    data.remove('')
+    module.exit_json(
+        changed=len(data) > 0,
+        msg="{} package(s) would be upgraded".format(len(data)),
+        helper=use,
+    )
+
+
+def upgrade(module, use, extra_args, aur_only):
     """
     Upgrade the whole system
     """
     assert use in use_cmd
 
-    rc, out, err = module.run_command(def_lang + use_cmd[use] + ['--aur' if (aur_only and use in has_aur_option) else None] + ['-u'], check_rc=True)
+    command = build_command_prefix(use, extra_args, aur_only=aur_only)
+    command.append('-u')
+
+    rc, out, err = module.run_command(command, check_rc=True)
 
     module.exit_json(
         changed=not (out == '' or 'nothing to do' in out or 'No AUR updates found' in out),
@@ -173,10 +249,13 @@ def upgrade(module, use, aur_only):
     )
 
 
-def install_packages(module, packages, use, state, aur_only):
+def install_packages(module, packages, use, extra_args, state, skip_pgp_check, ignore_arch, aur_only, local_pkgbuild):
     """
     Install the specified packages
     """
+    if local_pkgbuild:
+        assert use in use_cmd_local_pkgbuild
+    else:
         assert use in use_cmd
 
     changed_iter = False
@@ -187,9 +266,13 @@ def install_packages(module, packages, use, state, aur_only):
                 rc = 0
                 continue
         if use == 'makepkg':
-            rc, out, err = install_with_makepkg(module, package)
+            rc, out, err = install_with_makepkg(module, package, extra_args, skip_pgp_check, ignore_arch, local_pkgbuild)
+        elif local_pkgbuild:
+            rc, out, err = install_local_package(module, package, use, extra_args, local_pkgbuild)
         else:
-            rc, out, err = module.run_command(def_lang + use_cmd[use] + ['--aur' if (aur_only and use in has_aur_option) else None] + [package], check_rc=True)
+            command = build_command_prefix(use, extra_args, aur_only=aur_only)
+            command.append(package)
+            rc, out, err = module.run_command(command, check_rc=True)
 
         changed_iter = changed_iter or not (out == '' or '-- skipping' in out or 'nothing to do' in out)
 
@@ -203,7 +286,7 @@ def install_packages(module, packages, use, state, aur_only):
     )
 
 
-def main():
+def make_module():
     module = AnsibleModule(
         argument_spec={
             'name': {
@@ -213,53 +296,97 @@ def main():
                 'default': 'present',
                 'choices': ['present', 'latest'],
             },
-            'ignore_arch': {
-                'default': False,
-                'type': 'bool',
-            },
             'upgrade': {
-                'default': False,
                 'type': 'bool',
             },
             'use': {
                 'default': 'auto',
                 'choices': ['auto'] + list(use_cmd.keys()),
             },
+            'extra_args': {
+                'default': None,
+                'type': 'str',
+            },
             'skip_pgp_check': {
                 'default': False,
                 'type': 'bool',
             },
+            'ignore_arch': {
+                'default': False,
+                'type': 'bool',
+            },
             'aur_only': {
                 'default': False,
                 'type': 'bool',
             },
+            'local_pkgbuild': {
+                'default': None,
+                'type': 'path',
             },
+        },
+        mutually_exclusive=[['name', 'upgrade']],
         required_one_of=[['name', 'upgrade']],
         supports_check_mode=True
     )
 
     params = module.params
 
-    if module.check_mode:
+    use = params['use']
-        check_packages(module, params['name'])
 
-    if params['use'] == 'auto':
+    if use == 'auto':
+        if params['extra_args'] is not None:
+            module.fail_json(msg="'extra_args' cannot be used with 'auto', a tool must be specified.")
         use = 'makepkg'
         # auto: select the first helper for which the bin is found
         for k in use_cmd:
             if module.get_bin_path(k):
                 use = k
                 break
-    else:
-        use = params['use']
 
-    if params['upgrade'] and (params['name'] or use == 'makepkg'):
+    if use != 'makepkg' and (params['skip_pgp_check'] or params['ignore_arch']):
-        module.fail_json(msg="Upgrade cannot be used with this option.")
+        module.fail_json(msg="This option is only available with 'makepkg'.")
+
+    if not (use in use_cmd_local_pkgbuild) and params['local_pkgbuild']:
+        module.fail_json(msg="This option is not available with '%s'" % use)
+
+    if params['local_pkgbuild'] and not os.path.isdir(params['local_pkgbuild']):
+        module.fail_json(msg="Directory %s not found" % (params['local_pkgbuild']))
+
+    if params['local_pkgbuild'] and not os.access(params['local_pkgbuild'] + '/PKGBUILD', os.R_OK):
+        module.fail_json(msg="PKGBUILD inside %s not readable" % (params['local_pkgbuild']))
+
+    if params.get('upgrade', False) and use == 'makepkg':
+        module.fail_json(msg="The 'upgrade' action cannot be used with 'makepkg'.")
+
+    return module, use
+
+
+def apply_module(module, use):
+    params = module.params
+
+    if params.get('upgrade', False):
+        if module.check_mode:
+            check_upgrade(module, use)
         else:
-        if params['upgrade']:
+            upgrade(module, use, params['extra_args'], params['aur_only'])
-            upgrade(module, use, params['aur_only'])
     else:
-            install_packages(module, params['name'], use, params['state'], params['aur_only'])
+        if module.check_mode:
+            check_packages(module, params['name'])
+        else:
+            install_packages(module,
+                             params['name'],
+                             use,
+                             params['extra_args'],
+                             params['state'],
+                             params['skip_pgp_check'],
+                             params['ignore_arch'],
+                             params['aur_only'],
+                             params['local_pkgbuild'])
+
+
+def main():
+    module, use = make_module()
+    apply_module(module, use)
 
 
 if __name__ == '__main__':