add

library/ansible-keepassxc.py

@@ -0,0 +1,189 @@
+#!/usr/bin/python
+
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+import traceback
+from ansible.module_utils.basic import AnsibleModule, missing_required_lib
+
+IMPORT_ERR = None
+try:
+#    import _argon2_xffi_bindings
+    import pykeepass as keepass
+except ImportError:
+    IMPORT_ERR = traceback.format_exc()
+
+DOCUMENTATION = r'''
+---
+module: ansible-keepassxc
+
+short_description: Module to read credentials from KeePassXC
+
+version_added: "0.0.1"
+
+description: Module to read credentials from KeePassXC
+
+options:
+    database:
+        description: Path to database file
+        required: true
+        type: str
+    password:
+        description: Database Password
+        required: true
+        type: str
+    keyfile:
+        description: Path to key file
+        required: false
+        type: str
+    entry:
+        description: Entry name for the attribute to fetch
+        required: true
+        type: str
+    group:
+        decription: Group name that the Entry belongs to
+        required: false
+        type: str
+
+author:
+    - Jeremy Lumley (@jlumley)
+'''
+
+EXAMPLES = r'''
+# Fetch the credentials for the server_1 entry in any group
+- name: Fetch server_1 credentials
+  jlumley.jlumley.ansible-keepassxc:
+    database: "/secrets/db.kdbx"
+    password: "s3cure_p4550rd"
+    entry: "server_1"
+
+# Fetch the reddit entry in the social group
+- name: Fetching reddit credentials
+  jlumley.jlumley.ansible-keepassxc:
+    database: "/secrets/db.kdbx"
+    password: "sup3r_s3cure_p4550rd"
+    entry: "reddit"
+    group: "social"
+
+# Fetch a custom strig attribute from the github entry
+- name: Fetch Github API Token
+  jlumley.jlumley.ansible-keepassxc:
+    database: "/secrets/db.kdbx"
+    password: "d0pe_s3cure_p4550rd"
+    keyfile: "/secrets/top_secret_key"
+    entry: "github"
+    group: "development"
+
+'''
+
+RETURN = r'''
+# Return values
+username:
+    description: Username of entry if present
+    type: str
+    returned: always
+    sample: 's3cr3t_us3r'
+password:
+    description: Password of entry if present
+    type: str
+    returned: always
+    sample: 's3cr3t_p455word'
+url:
+    description: Url of entry if present
+    type: str
+    returned: always
+    sample: 'http://reddit.com'
+custom_fields:
+    description: dictionary containing all custom fields
+    type: dict
+    returned: always
+    sample: False
+no_log:
+    description: suppress logging of password
+    type: bool
+    returned: never
+    sample: False
+'''
+
+def run_module():
+    # define available arguments/parameters a user can pass to the module
+    module_args = dict(
+        database    = dict(type='str', required=True),
+        password    = dict(type='str', required=False,
+                           default=os.environ.get('ANSIBLE_KEEPASSXC_PASSWORD')),
+        keyfile     = dict(type='str', required=False, default=None),
+        entry       = dict(type='str', required=True),
+        group       = dict(type='str', required=False),
+        no_log     = dict(type='bool', required=False, default=False),
+    )
+
+    # seed the result dict in the object
+    result = dict(
+        changed=False,
+        username='',
+        password='',
+        url='',
+        custom_fields={}
+    )
+
+    # Currently no support for a check_mode this maybe added later if
+    # functionality to modify the database is added later
+    module = AnsibleModule(
+        argument_spec=module_args,
+        supports_check_mode=False,
+    )
+
+    if IMPORT_ERR:
+        module.fail_json(
+            msg=missing_required_lib("pykeepass"),
+            exception=IMPORT_ERR
+        )
+
+    # unlock local keepass database
+    try:
+        kp = keepass.PyKeePass(
+            module.params['database'],
+            password=module.params['password'],
+            keyfile=module.params['keyfile'])
+    except keepass.exceptions.CredentialsError:
+        module.fail_json(msg='Invalid Credentials')
+
+    # find entry
+    entry = kp.find_entries(
+        title=module.params['entry'],
+        group=module.params['group']
+    )
+
+    # fail is entry is not present
+    if not entry:
+        module.fail_json(msg=f"Unable to find entry: {module.params['entry']}")
+
+    else:
+        entry = entry[0]
+        custom_field_keys = entry._get_string_field_keys(exclude_reserved=True)
+        custom_fields = dict()
+        for key in custom_field_keys:
+            custom_fields[key] = entry.get_custom_property(key)
+        result = dict (
+            changed=False,
+            username=entry.username,
+            password=entry.password,
+            url=entry.url,
+            custom_fields=custom_fields
+        )
+
+    # in the event of a successful module execution, you will want to
+    # simple AnsibleModule.exit_json(), passing the key/value results
+    module.exit_json(**result)
+
+
+def main():
+    run_module()
+
+
+if __name__ == '__main__':
+    main()
+
+

library/ansible_gentooimgr.py

@@ -0,0 +1,224 @@
+#!/usr/bin/python3
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+import sys
+import logging
+from argparse import Namespace
+import pathlib
+import traceback
+
+sys.path.append('/mnt/o/var/local/src/play_tox/src/ansible_gentooimgr')
+# in the library
+mod_path = os.path.dirname(os.path.realpath('__file__'))
+mod_path = os.path.join(mod_path, 'src', 'ansible_gentooimgr')
+assert os.path.isdir(mod_path), f"parent {mod_path}"
+assert os.path.isfile(os.path.join(mod_path, '__init__.py')),f"index {mod_path}"
+assert os.path.isdir(os.path.join(mod_path, 'gentooimgr')), f"sub {mod_path}"
+sys.path.append(mod_path)
+try:
+    import gentooimgr
+except Exception as e:
+    sys.stderr.write(f"{mod_path} {sys.path} {traceback.print_exc()}")
+    raise
+import ansible
+
+DOCUMENTATION = rf'''
+---
+module: gentooimgr
+
+short_description: Gentoo Image Builder for Cloud and Turnkey ISO installers
+
+
+version_added: "1.0.0"
+
+description:
+* This project enables easy access to building ``systemd`` or ``openrc`` -based images.
+* Performs automatic download AND verification of the linux iso, stage3 tarball and portage.
+* Caches the iso and stage3 .txt files for at most a day before redownloading and rechecking for new files
+* Sane and readable cli commands to build, run and test.
+* Step system to enable user to continue off at the same place if a step fails
+* No heavy packages like rust included ** TODO
+
+options:
+    action:
+        description: The action to be run by the image builder
+        choices:
+            - build
+            - run
+            - status
+            - install
+            - chroot
+            - unchroot
+            - command
+            - shrink
+            - kernel
+        required: true
+        # clean test
+    config:
+        default: cloud.json
+        description: init configuration file or or base.json or cloud.json
+        required: false
+    loglevel:
+        default: {logging.INFO}
+        description: python logging level <= 50, INFO=20
+        required: false
+    threads:
+        default: 1
+        description: Number of threads to use
+        required: false
+    profile:
+        default: openrc
+        description: The init system
+        choices:
+            - openrc
+            - systemd
+        required: false
+    kernel_dir:
+        default: /usr/src/linux
+        description: Where kernel is specified. By default uses the active linux kernel
+        required: false
+    portage:
+        description: Extract the specified portage tarball onto the filesystem
+        required: false
+    stage3:
+        description: Extract the specified stage3 package onto the filesystema
+        required: false
+    action_args:
+        default: []
+        description: Arguments for some of the actions - UNUSED!
+        required: false
+    temporary_dir:
+        description: Path to temporary directory for downloading files (20G)
+        required: false
+    qcow:
+        description: Path to file to serve as the base image
+        required: false
+
+# Specify this value according to your collection
+# in format of namespace.collection.doc_fragment_name
+# extends_documentation_fragment:
+#     - my_namespace.my_collection.my_doc_fragment_name
+
+author:
+    - Your Name (@yourGitHubHandle)
+'''
+
+#[-y DAYS]
+#                  [-d DOWNLOAD_DIR]
+# [-f]
+#                  [--format FORMAT]
+
+EXAMPLES = r'''
+# Pass in a message
+- name: Test with a message
+  my_namespace.my_collection.my_test:
+    name: hello world
+
+# pass in a message and have changed true
+- name: Test with a message and changed output
+  my_namespace.my_collection.my_test:
+    name: hello world
+    new: true
+
+# fail the module
+- name: Test failure of the module
+  my_namespace.my_collection.my_test:
+    name: fail me
+'''
+
+RETURN = r'''
+# These are examples of possible return values, and in general should use other names for return values.
+message:
+    description: The output message that the test module generates.
+    type: str
+    returned: always
+    sample: 'goodbye'
+'''
+
+from ansible.module_utils.basic import AnsibleModule
+
+
+def run_module():
+    # define available arguments/parameters a user can pass to the module
+    module_args = dict(
+        action=dict(type='str', required=True),
+        loglevel=dict(type='int', required=False, default=logging.INFO),
+        threads=dict(type='int', required=False, default=1),
+        config=dict(type='str', default='cloud.json', required=False),
+        profile=dict(type='str', required=False),
+        kernel_dir=dict(type='path', required=False),
+        portage=dict(type='path', required=False),
+        stage3=dict(type='path', required=False),
+        temporary_dir=dict(type='path', required=False, default=pathlib.Path(os.getcwd())),
+        download_dir=dict(type='path', required=False, default=pathlib.Path(os.getcwd())),
+        qcow=dict(type='path', required=False),
+    )
+
+    # seed the result dict in the object
+    # we primarily care about changed and state
+    # changed is if this module effectively modified the target
+    # state will include any data that you want your module to pass back
+    # for consumption, for example, in a subsequent task
+    result = dict(
+        changed=False,
+        original_message='',
+        message=''
+    )
+
+    # the AnsibleModule object will be our abstraction working with Ansible
+    # this includes instantiation, a couple of common attr would be the
+    # args/params passed to the execution, as well as if the module
+    # supports check mode
+    module = AnsibleModule(
+        argument_spec=module_args,
+        supports_check_mode=True
+    )
+
+    # if the user is working with this module in only check mode we do not
+    # want to make any changes to the environment, just return the current
+    # state with no modifications
+    if module.check_mode:
+        module.exit_json(**result)
+
+    # manipulate or modify the state as needed (this is going to be the
+    # part where your module will do what it needs to do)
+    # if module.params.get('thirsty'):
+
+    oargs = Namespace(**module.params)
+    # during the execution of the module, if there is an exception or a
+    # conditional state that effectively causes a failure, run
+    # AnsibleModule.fail_json() to pass in the message and the result
+    result['original_message'] = ""
+    try:
+        from gentooimgr.__main__ import main
+        retval = main(oargs)
+    except Exception as e:
+        result['message'] = str(e)
+        e = traceback.print_exc()
+        if e: result['original_message'] += f"{e}"
+        module.fail_json(msg='Exception', **result)
+    else:
+        result['message'] = str(retval)
+
+    # use whatever logic you need to determine whether or not this module
+    # made any modifications to your target
+    if dArgs['action'] in ['status']:
+        result['changed'] = False
+    else:
+        result['changed'] = True
+
+    # in the event of a successful module execution, you will want to
+    # simple AnsibleModule.exit_json(), passing the key/value results
+    module.exit_json(**result)
+
+
+def main():
+    run_module()
+
+
+if __name__ == '__main__':
+    main()
+