ansible-aur/plugins/modules/aur.py

398 lines
13 KiB
Python
Raw Normal View History

2018-05-23 23:01:47 +03:00
#!/usr/bin/python
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
2017-12-23 20:27:42 +03:00
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.urls import open_url
2017-12-31 20:12:28 +03:00
import json
import shlex
2017-12-31 20:12:28 +03:00
import tarfile
import os
import os.path
2020-09-24 13:31:55 +03:00
import shutil
2017-12-31 20:12:28 +03:00
import tempfile
import urllib.parse
2017-12-31 20:12:28 +03:00
2018-04-14 13:53:14 +03:00
2018-05-23 23:01:47 +03:00
DOCUMENTATION = '''
---
2018-05-23 23:25:05 +03:00
module: aur
short_description: Manage packages from the AUR
2018-05-23 23:01:47 +03:00
description:
2018-05-23 23:07:53 +03:00
- Manage packages from the Arch User Repository (AUR)
2018-05-23 23:01:47 +03:00
author:
- Kewl <xrjy@nygb.rh.bet(rot13)>
options:
name:
description:
- Name or list of names of the package(s) to install or upgrade.
2020-05-24 05:28:10 +03:00
state:
description:
- Desired state of the package.
default: present
choices: [ present, latest ]
2018-05-23 23:01:47 +03:00
upgrade:
description:
- Whether or not to upgrade whole system.
default: no
2018-05-23 23:01:47 +03:00
type: bool
use:
description:
- The tool to use, 'auto' uses the first known helper found and makepkg as a fallback.
2018-05-23 23:01:47 +03:00
default: auto
2021-01-26 20:41:55 +03:00
choices: [ auto, yay, paru, pacaur, trizen, pikaur, aurman, makepkg ]
2018-05-23 23:01:47 +03:00
extra_args:
2020-05-31 05:34:04 +03:00
description:
- Arguments to pass to the tool.
2020-05-31 05:34:04 +03:00
Requires that the 'use' option be set to something other than 'auto'.
type: str
2020-05-31 05:34:04 +03:00
2018-05-23 23:01:47 +03:00
skip_pgp_check:
description:
2020-04-13 02:40:51 +03:00
- Only valid with makepkg.
Skip PGP signatures verification of source file.
2020-04-13 02:45:52 +03:00
This is useful when installing packages without GnuPG (properly) configured.
Cannot be used unless use is set to 'makepkg'.
2020-04-13 02:40:51 +03:00
type: bool
default: no
ignore_arch:
description:
- Only valid with makepkg.
2020-04-13 02:45:52 +03:00
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'.
2018-05-23 23:01:47 +03:00
type: bool
default: no
2018-07-25 23:19:02 +03:00
aur_only:
description:
2020-05-24 17:08:21 +03:00
- Limit helper operation to the AUR.
2020-05-30 20:10:01 +03:00
type: bool
default: no
2020-09-24 13:31:55 +03:00
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
2018-05-23 23:01:47 +03:00
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.
'''
RETURN = '''
msg:
description: action that has been taken
helper:
description: the helper that was actually used
2018-05-23 23:01:47 +03:00
'''
EXAMPLES = '''
- name: Install trizen using makepkg, skip if trizen is already installed
2020-05-24 05:28:10 +03:00
aur: name=trizen use=makepkg state=present
2018-05-23 23:01:47 +03:00
become: yes
become_user: aur_builder
'''
def_lang = ['env', 'LC_ALL=C', 'LANGUAGE=C']
2018-03-17 11:15:06 +03:00
2017-12-31 20:12:28 +03:00
use_cmd = {
2018-11-15 23:08:23 +03:00
'yay': ['yay', '-S', '--noconfirm', '--needed', '--cleanafter'],
2021-01-26 20:41:55 +03:00
'paru': ['paru', '-S', '--noconfirm', '--needed', '--cleanafter'],
2018-05-08 09:20:00 +03:00
'pacaur': ['pacaur', '-S', '--noconfirm', '--noedit', '--needed'],
'trizen': ['trizen', '-S', '--noconfirm', '--noedit', '--needed'],
2018-03-17 11:15:06 +03:00
'pikaur': ['pikaur', '-S', '--noconfirm', '--noedit', '--needed'],
2020-04-13 03:00:50 +03:00
'aurman': ['aurman', '-S', '--noconfirm', '--noedit', '--needed', '--skip_news', '--pgp_fetch', '--skip_new_locations'],
'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
2017-12-23 20:27:42 +03:00
}
2018-07-25 23:19:02 +03:00
2020-09-24 13:31:55 +03:00
use_cmd_local_pkgbuild = {
'pikaur': ['pikaur', '-P', '--noconfirm', '--noedit', '--needed', '--install'],
'makepkg': ['makepkg', '--syncdeps', '--install', '--noconfirm', '--needed']
}
2021-01-26 20:41:55 +03:00
has_aur_option = ['yay', 'paru', 'pacaur', 'trizen', 'pikaur', 'aurman']
2017-12-23 20:27:42 +03:00
2017-12-31 20:12:28 +03:00
def package_installed(module, package):
2018-05-16 22:30:58 +03:00
"""
Determine if the package is already installed
"""
2017-12-31 20:12:28 +03:00
rc, _, _ = module.run_command(['pacman', '-Q', package], check_rc=False)
return rc == 0
2018-05-16 21:39:57 +03:00
def check_packages(module, packages):
"""
Inform the user what would change if the module were run
"""
would_be_changed = []
2020-05-10 15:31:49 +03:00
diff = {
'before': '',
'after': '',
}
2018-05-16 21:39:57 +03:00
for package in packages:
installed = package_installed(module, package)
if not installed:
would_be_changed.append(package)
2020-05-10 15:31:49 +03:00
if module._diff:
diff['after'] += package + "\n"
2018-05-16 21:39:57 +03:00
if would_be_changed:
status = True
2019-04-11 21:59:22 +03:00
if len(packages) > 1:
message = '{} package(s) would be installed'.format(len(would_be_changed))
2018-05-16 21:39:57 +03:00
else:
message = 'package would be installed'
else:
status = False
2019-04-11 21:59:22 +03:00
if len(packages) > 1:
2018-05-16 21:39:57 +03:00
message = 'all packages are already installed'
else:
message = 'package is already installed'
2020-05-10 15:31:49 +03:00
module.exit_json(changed=status, msg=message, diff=diff)
2018-05-16 21:39:57 +03:00
2020-09-24 13:31:55 +03:00
def build_command_prefix(use, extra_args, skip_pgp_check=False, ignore_arch=False, aur_only=False, local_pkgbuild=None):
"""
Create the prefix of a command that can be used by the install and upgrade functions.
"""
2020-09-24 13:31:55 +03:00
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')
2020-09-24 13:31:55 +03:00
if local_pkgbuild and use != 'makepkg':
command.append(local_pkgbuild)
if extra_args:
command += shlex.split(extra_args)
return command
2020-09-24 13:31:55 +03:00
def install_with_makepkg(module, package, extra_args, skip_pgp_check, ignore_arch, local_pkgbuild=None):
2018-05-16 22:30:58 +03:00
"""
2020-09-24 13:31:55 +03:00
Install the specified package or a local PKGBUILD with makepkg
2018-05-16 22:30:58 +03:00
"""
2020-09-24 13:31:55 +03:00
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'))
if result['resultcount'] != 1:
return (1, '', 'package {} not found'.format(package))
result = result['results'][0]
f = open_url('https://aur.archlinux.org/{}'.format(result['URLPath']))
2017-12-31 20:12:28 +03:00
with tempfile.TemporaryDirectory() as tmpdir:
2020-09-24 13:31:55 +03:00
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()
command = build_command_prefix('makepkg', extra_args, skip_pgp_check=skip_pgp_check, ignore_arch=ignore_arch)
rc, out, err = module.run_command(command, cwd=os.path.join(tmpdir, result['Name']), check_rc=True)
return (rc, out, err)
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)
2017-12-31 20:12:28 +03:00
return (rc, out, err)
2017-12-23 20:27:42 +03:00
2020-08-09 00:58:32 +03:00
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):
2018-05-16 22:30:58 +03:00
"""
Upgrade the whole system
"""
2017-12-31 20:12:28 +03:00
assert use in use_cmd
command = build_command_prefix(use, extra_args, aur_only=aur_only)
command.append('-u')
rc, out, err = module.run_command(command, check_rc=True)
2017-12-23 20:27:42 +03:00
module.exit_json(
2021-04-16 10:20:52 +03:00
changed=not (out == '' or 'nothing to do' in out.lower() or 'No AUR updates found' in out),
2017-12-23 20:27:42 +03:00
msg='upgraded system',
helper=use,
2017-12-23 20:27:42 +03:00
)
2020-09-24 13:31:55 +03:00
def install_packages(module, packages, use, extra_args, state, skip_pgp_check, ignore_arch, aur_only, local_pkgbuild):
2018-05-16 22:30:58 +03:00
"""
Install the specified packages
"""
2020-09-24 13:31:55 +03:00
if local_pkgbuild:
assert use in use_cmd_local_pkgbuild
else:
assert use in use_cmd
2017-12-23 20:27:42 +03:00
2017-12-23 23:05:07 +03:00
changed_iter = False
2017-12-23 20:27:42 +03:00
2017-12-31 20:12:28 +03:00
for package in packages:
2020-05-24 05:44:58 +03:00
if state == 'present':
2017-12-31 20:12:28 +03:00
if package_installed(module, package):
rc = 0
continue
if use == 'makepkg':
2020-09-24 13:31:55 +03:00
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)
2017-12-31 20:12:28 +03:00
else:
command = build_command_prefix(use, extra_args, aur_only=aur_only)
command.append(package)
rc, out, err = module.run_command(command, check_rc=True)
2021-04-16 10:20:52 +03:00
changed_iter = changed_iter or not (out == '' or '-- skipping' in out or 'nothing to do' in out.lower())
2017-12-23 20:27:42 +03:00
2019-04-11 22:03:55 +03:00
message = 'installed package(s)' if changed_iter else 'package(s) already installed'
2017-12-23 20:27:42 +03:00
module.exit_json(
2017-12-23 23:05:07 +03:00
changed=changed_iter,
msg=message if not rc else err,
helper=use,
2017-12-31 20:12:28 +03:00
rc=rc,
2017-12-23 20:27:42 +03:00
)
2020-05-30 21:57:56 +03:00
def make_module():
2017-12-23 20:27:42 +03:00
module = AnsibleModule(
argument_spec={
'name': {
2017-12-23 23:05:07 +03:00
'type': 'list',
2017-12-23 20:27:42 +03:00
},
2020-05-24 05:28:10 +03:00
'state': {
'default': 'present',
'choices': ['present', 'latest'],
},
2017-12-23 20:27:42 +03:00
'upgrade': {
'type': 'bool',
},
2017-12-24 10:21:11 +03:00
'use': {
'default': 'auto',
2019-04-11 21:39:01 +03:00
'choices': ['auto'] + list(use_cmd.keys()),
2017-12-31 20:12:28 +03:00
},
'extra_args': {
'default': None,
'type': 'str',
2020-05-31 05:34:04 +03:00
},
'skip_pgp_check': {
'default': False,
'type': 'bool',
},
2020-05-30 20:10:01 +03:00
'ignore_arch': {
'default': False,
'type': 'bool',
},
2018-07-25 23:19:02 +03:00
'aur_only': {
'default': False,
'type': 'bool',
},
2020-09-24 13:31:55 +03:00
'local_pkgbuild': {
'default': None,
'type': 'path',
},
2017-12-23 20:27:42 +03:00
},
2020-05-30 20:10:01 +03:00
mutually_exclusive=[['name', 'upgrade']],
2017-12-23 20:27:42 +03:00
required_one_of=[['name', 'upgrade']],
2018-05-16 21:39:57 +03:00
supports_check_mode=True
2017-12-23 20:27:42 +03:00
)
params = module.params
2020-06-01 02:56:33 +03:00
use = params['use']
2018-05-16 21:39:57 +03:00
2021-01-21 00:57:45 +03:00
if params['name'] == []:
module.fail_json(msg="'name' cannot be empty.")
2020-06-01 02:56:33 +03:00
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'
2018-05-08 09:20:00 +03:00
# auto: select the first helper for which the bin is found
2017-12-31 20:12:28 +03:00
for k in use_cmd:
if module.get_bin_path(k):
2017-12-31 20:12:28 +03:00
use = k
2017-12-24 10:21:11 +03:00
break
if use != 'makepkg' and (params['skip_pgp_check'] or params['ignore_arch']):
module.fail_json(msg="This option is only available with 'makepkg'.")
2020-09-24 13:31:55 +03:00
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']))
2020-05-30 20:10:01 +03:00
if params.get('upgrade', False) and use == 'makepkg':
module.fail_json(msg="The 'upgrade' action cannot be used with 'makepkg'.")
2020-05-30 20:10:01 +03:00
2020-05-30 21:57:56 +03:00
return module, use
def apply_module(module, use):
params = module.params
2020-08-09 00:58:32 +03:00
if params.get('upgrade', False):
if module.check_mode:
check_upgrade(module, use)
else:
upgrade(module, use, params['extra_args'], params['aur_only'])
2017-12-23 20:27:42 +03:00
else:
2020-08-09 00:58:32 +03:00
if module.check_mode:
check_packages(module, params['name'])
else:
2020-09-24 13:31:55 +03:00
install_packages(module,
params['name'],
use,
params['extra_args'],
params['state'],
params['skip_pgp_check'],
params['ignore_arch'],
params['aur_only'],
params['local_pkgbuild'])
2017-12-23 20:27:42 +03:00
2020-05-30 21:57:56 +03:00
def main():
module, use = make_module()
apply_module(module, use)
2017-12-23 20:27:42 +03:00
if __name__ == '__main__':
main()