collection/plugins/modules/folder.py

@@ -37,7 +37,7 @@ options:
         required: false
     devices:
         description:
-            - List of device ids to share folder with. Always share with self.
+            - List of devices to share folder with
         required: false
     fs_watcher:
         description:
@@ -84,20 +84,12 @@ author:
 
 EXAMPLES = '''
 # Add a folder to synchronize with another device
- - name: Create folder
+- name: Add syncthing folder
-   become: yes
+  syncthing_folder:
-   become_user: syncthing
+    id: box
-   community.syncthing.folder:
+    path: ~/box
-     host: http://localhost
+    devices:
-     unix_socket: /run/syncthing/syncthing.sock
+      - 1234-1234-1234-1234
-     config_file: /var/lib/syncthing/.config/syncthing/config.xml
-     id: 'my-folder-1'
-     label: 'my folder 1'
-     path: '/root/test-folder-1'
-     devices:
-       - '1234-1234-1234'
-       - '5678-5678-5678'
-   register: folder
 '''
 
 RETURN = '''
@@ -106,18 +98,129 @@ response:
     type: dict
 '''
 
-from ansible_collections.community.syncthing.plugins.module_utils.syncthing_api import SyncthingModule
+import os
+import json
+import platform
+from xml.etree.ElementTree import parse
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.urls import fetch_url, url_argument_spec
+
+SYNCTHING_API_BASE_URI = "/rest"
+if platform.system() == 'Windows':
+    DEFAULT_ST_CONFIG_LOCATION = '%localappdata%/Syncthing/config.xml'
+elif platform.system() == 'Darwin':
+    DEFAULT_ST_CONFIG_LOCATION = '$HOME/Library/Application Support/Syncthing/config.xml'
+else:
+    DEFAULT_ST_CONFIG_LOCATION = '$HOME/.config/syncthing/config.xml'
+
+
+def make_headers(host, api_key, resource):
+    url = '{}{}/{}'.format(host, SYNCTHING_API_BASE_URI, resource)
+    headers = {'X-Api-Key': api_key }
+    return url, headers
+
+def get_key_from_filesystem(module):
+    try:
+        if module.params['config_file']:
+            stconfigfile = module.params['config_file']
+        else:
+            stconfigfile = os.path.expandvars(DEFAULT_ST_CONFIG_LOCATION)
+        stconfig = parse(stconfigfile)
+        root = stconfig.getroot()
+        gui = root.find('gui')
+        api_key = gui.find('apikey').text
+        return api_key
+    except Exception:
+        module.fail_json(msg="Auto-configuration failed. Please specify"
+                             "the API key manually.")
+
+def get_data_from_rest_api(module, resource):
+    url, headers = make_headers(
+        module.params['host'], module.params['api_key'], resource
+    )
+    resp, info = fetch_url(
+        module,
+        url,
+        data=None,
+        headers=headers,
+        method='GET',
+        timeout=module.params['timeout']
+    )
+
+    if not info or info['status'] != 200:
+        result['response'] = info
+        module.fail_json(msg='Error occured while calling host', **result)
+
+    try:
+        content = resp.read()
+    except AttributeError:
+        result['content'] = info.pop('body', '')
+        result['response'] = str(info)
+        module.fail_json(msg='Error occured while reading response', **result)
+
+    return json.loads(content)
+
+# Fetch Syncthing configuration
+def get_config(module):
+    return get_data_from_rest_api(module, 'system/config')
+
+# Fetch Syncthing status
+def get_status(module):
+    return get_data_from_rest_api(module, 'system/status')
+
+# Get the device name -> device ID mapping.
+def get_devices_mapping(config):
+    return {
+        device['name']: device['deviceID'] for device in config['devices']
+    }
+
+# Get the folder configuration from the global configuration, if it exists
+def get_folder_config(folder_id, config):
+    for folder in config['folders']:
+        if folder['id'] == folder_id:
+            return folder
+    return None
+
+# Post the new configuration to Syncthing API
+def post_config(module, config, result):
+    url, headers = make_headers(
+        module.params['host'],
+        module.params['api_key'],
+        'system/config',
+    )
+    headers['Content-Type'] = 'application/json'
+
+    result['msg'] = config
+    resp, info = fetch_url(
+        module, url, data=json.dumps(config), headers=headers,
+        method='POST', timeout=module.params['timeout'])
+
+    if not info or info['status'] != 200:
+        result['response'] = str(info)
+        module.fail_json(**result)
 
 # Returns an object of a new folder
-def create_folder(params, self_id, existing_device_ids):
+def create_folder(params, self_id, current_device_ids, devices_mapping):
+    # We need the current device ID as per the Syncthing API.
+    # If missing, Syncthing will add it alright, but we don't want to give
+    # the false idea that this configuration is different just because of that.
     wanted_device_ids = {self_id}
-    for device_id in params['devices']:
+    for device_name_or_id in params['devices']:
-        if device_id in existing_device_ids:
+        if device_name_or_id in devices_mapping:
-            wanted_device_ids.add(device_id)
+            wanted_device_ids.add(devices_mapping[device_name_or_id])
+        else:
+            # Purposefully do not validate we already know this device ID or
+            # name as per previous behavior.  This will need to be fixed.
+            wanted_device_ids.add(device_name_or_id)
 
     # Keep the original ordering if collections are equivalent.
     # Again, for idempotency reasons.
-    device_ids = sorted(wanted_device_ids)
+    device_ids = (
+        current_device_ids
+        if set(current_device_ids) == wanted_device_ids
+        else sorted(wanted_device_ids)
+    )
 
     # Sort the device IDs to keep idem-potency
     devices = [
@@ -163,102 +266,80 @@ def create_folder(params, self_id, existing_device_ids):
         'weakHashThresholdPct': 25
     }
 
-def update_folder(folder, params, self_id, existing_device_ids):
-    wanted_device_ids = {self_id}
-    for device_id in params['devices']:
-        if device_id in existing_device_ids:
-            wanted_device_ids.add(device_id)
-
-    current_device_ids = {d['deviceID'] for d in folder['devices']}
-    device_ids = (
-        current_device_ids
-        if current_device_ids == wanted_device_ids
-        else sorted(wanted_device_ids)
-    )
-
-    # Sort the device IDs to keep idem-potency
-    devices = [
-        {
-            'deviceID': device_id,
-            'introducedBy': '',
-        } for device_id in device_ids
-    ]
-
-    folder.update({
-        'devices': devices,
-        'fsWatcherEnabled': params['fs_watcher'],
-        'ignorePerms': params['ignore_perms'],
-        'label': params['label'] if params['label'] else params['id'],
-        'path': params['path'],
-        'paused': True if params['state'] == 'paused' else False,
-        'type': params['type'],
-    })
-
-    return folder
-
 def run_module():
     # module arguments
-    module_args = {}
+    module_args = url_argument_spec()
     module_args.update(dict(
         id=dict(type='str', required=True),
         label=dict(type='str', required=False),
         path=dict(type='path', required=False),
-        devices=dict(type='list', required=False, default=[]),
+        devices=dict(type='list', required=False, default=False),
         fs_watcher=dict(type='bool', default=True),
         ignore_perms=dict(type='bool', required=False, default=False),
         type=dict(type='str', default='sendreceive',
             choices=['sendreceive', 'sendonly', 'receiveonly']),
+        host=dict(type='str', default='http://127.0.0.1:8384'),
+        api_key=dict(type='str', required=False, no_log=True),
+        config_file=dict(type='path', required=False),
+        timeout=dict(type='int', default=30),
         state=dict(type='str', default='present',
                    choices=['absent', 'present', 'pause']),
     ))
 
-    module = SyncthingModule(
+    # seed the result dict in the object
-        api_url='/rest/config/folders',
+    result = {
-        argument_spec=module_args
+        "changed": False,
-    )
+        "response": None,
+    }
 
-    device_module = SyncthingModule(
+    # the AnsibleModule object will be our abstraction working with Ansible
-        api_url='/rest/config/devices',
+    module = AnsibleModule(
-        argument_spec=module_args
+        argument_spec=module_args,
+        supports_check_mode=True
     )
 
     if module.params['state'] != 'absent' and not module.params['path']:
-        module.fail_json(msg='You must provide a path when creating')
+        module.fail_json(msg='You must provide a path when creating', **result)
 
-    folder_exists = False
+    if module.check_mode:
-    folder = module.get_call(target=module.params['id'])
+        return result
-    if 'id' in folder and folder['id'] == module.params['id']:
-        folder_exists = True
 
+    # Auto-configuration: Try to fetch API key from filesystem
+    if not module.params['api_key']:
+        module.params['api_key'] = get_key_from_filesystem(module)
+
+    config = get_config(module)
+    self_id = get_status(module)['myID']
+    devices_mapping = get_devices_mapping(config)
     if module.params['state'] == 'absent':
-        if folder_exists:
+        # Remove folder from list, if found
-            if module.check_mode:
+        for idx, folder in enumerate(config['folders']):
-                module.result['changed'] = True
+            if folder['id'] == module.params['id']:
-            else:
+                config['folders'].pop(idx)
-                module.delete_call(target=folder['id'])
+                result['changed'] = True
+                break
     else:
-        devices_list = device_module.get_call()
+        folder_config = get_folder_config(module.params['id'], config)
-        existing_device_ids = [device['deviceID'] for device in devices_list]
+        folder_config_devices = (
-        self_id = device_module.result['response']['x-syncthing-id']
+            [d['deviceID'] for d in folder_config['devices']] if folder_config else []
+        )
+        folder_config_wanted = create_folder(
+            module.params, self_id, folder_config_devices, devices_mapping
+        )
 
-        if folder_exists:  # exists but maybe needs changing
+        if folder_config is None:
-            if module.check_mode:
+            config['folders'].append(folder_config_wanted)
-                module.result['changed'] = True
+            result['changed'] = True
-            else:
+        elif folder_config != folder_config_wanted:
-                folder_with_updated_data = update_folder(
+            # Update the folder configuration in-place
-                    folder, module.params, self_id, existing_device_ids
+            folder_config.clear()
-                )
+            folder_config.update(folder_config_wanted)
-                module.patch_call(data=folder_with_updated_data, target=folder['id'])
+            result['changed'] = True
-        else:  # Doesn't exist but needs to be added
-            if module.check_mode:
-                module.result['changed'] = True
-            else:
-                folder_config_wanted = create_folder(
-                    module.params, self_id, existing_device_ids
-                )
-                module.post_call(data=folder_config_wanted)
 
-    module.exit_json()
+    if result['changed']:
+        post_config(module, config, result)
+
+    module.exit_json(**result)
 
 def main():
     run_module()

collection/plugins/modules/folder_defaults.py

@@ -1,381 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-
-# Copyright: (c) 2018, Rafael Bodill <justrafi at google mail>
-# Copyright: (c) 2020, Borjan Tchakaloff <first name at last name dot fr>
-# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
-
-ANSIBLE_METADATA = {
-    'metadata_version': '1.1',
-    'status': ['preview'],
-    'supported_by': 'community'
-}
-
-DOCUMENTATION = '''
----
-module: folder_defaults
-
-short_description: Manage Syncthing folder default configurations
-
-version_added: "2.7"
-
-description:
-    - "This module allows you to manage Syncthing folder default configurations. 
-       You can update the default configurations using this module. 
-       It uses the Syncthing REST API to perform these operations."
-
-options:
-    id:
-        description:
-            - The ID of the module.
-        type: str
-        required: false
-    label:
-        description:
-            - The label for the module.
-        type: str
-        required: false
-    filesystemType:
-        description:
-            - The filesystem type for the module.
-        type: str
-        required: false
-        default: basic
-    path:
-        description:
-            - The path for the module.
-        type: str
-        required: false
-        default: ~
-    type:
-        description:
-            - The type of the module.
-        type: str
-        required: false
-        default: sendreceive
-        choices: [sendreceive, sendonly, receiveonly]
-    devices:
-        description:
-            - List of devices for the module.
-        type: list
-        required: false
-        default: []
-    rescanIntervalS:
-        description:
-            - The rescan interval for the module in seconds.
-        type: int
-        required: false
-        default: 3600
-    fsWatcherEnabled:
-        description:
-            - Whether the filesystem watcher is enabled for the module.
-        type: bool
-        required: false
-        default: true
-    fsWatcherDelayS:
-        description:
-            - The filesystem watcher delay for the module in seconds.
-        type: int
-        required: false
-        default: 10
-    ignorePerms:
-        description:
-            - Whether to ignore permissions for the module.
-        type: bool
-        required: false
-        default: false
-    autoNormalize:
-        description:
-            - Whether to automatically normalize for the module.
-        type: bool
-        required: false
-        default: true
-    minDiskFree:
-        description:
-            - The minimum disk free for the module.
-        type: dict
-        required: false
-        default: {value: 1, unit: '%'}
-    versioning:
-        description:
-            - The versioning for the module.
-        type: dict
-        required: false
-        default: {type: '', params: {}, cleanupIntervalS: 3600, fsPath: '', fsType: 'basic'}
-    copiers:
-        description:
-            - The number of copiers for the module.
-        type: int
-        required: false
-        default: 0
-    pullerMaxPendingKiB:
-        description:
-            - The maximum pending puller size for the module in KiB.
-        type: int
-        required: false
-        default: 0
-    hashers:
-        description:
-            - The number of hashers for the module.
-        type: int
-        required: false
-        default: 0
-    order:
-        description:
-            - The order for the module.
-        type: str
-        required: false
-        default: random
-    ignoreDelete:
-        description:
-            - Whether to ignore delete for the module.
-        type: bool
-        required: false
-        default: false
-    scanProgressIntervalS:
-        description:
-            - The scan progress interval for the module in seconds.
-        type: int
-        required: false
-        default: 0
-    pullerPauseS:
-        description:
-            - The puller pause for the module in seconds.
-        type: int
-        required: false
-        default: 0
-    maxConflicts:
-        description:
-            - The maximum number of conflicts for the module.
-        type: int
-        required: false
-        default: 10
-    disableSparseFiles:
-        description:
-            - Whether to disable sparse files for the module.
-        type: bool
-        required: false
-        default: false
-    disableTempIndexes:
-        description:
-            - Whether to disable temporary indexes for the module.
-        type: bool
-        required: false
-        default: false
-    paused:
-        description:
-            - Whether the module is paused.
-        type: bool
-        required: false
-        default: false
-    weakHashThresholdPct:
-        description:
-            - The weak hash threshold for the module in percentage.
-        type: int
-        required: false
-        default: 25
-    markerName:
-        description:
-            - The marker name for the module.
-        type: str
-        required: false
-        default: .stfolder
-    copyOwnershipFromParent:
-        description:
-            - Whether to copy ownership from parent for the module.
-        type: bool
-        required: false
-        default: false
-    modTimeWindowS:
-        description:
-            - The modification time window for the module in seconds.
-        type: int
-        required: false
-        default: 0
-    maxConcurrentWrites:
-        description:
-            - The maximum number of concurrent writes for the module.
-        type: int
-        required: false
-        default: 2
-    disableFsync:
-        description:
-            - Whether to disable fsync for the module.
-        type: bool
-        required: false
-        default: false
-    blockPullOrder:
-        description:
-            - The block pull order for the module.
-        type: str
-        required: false
-        default: standard
-    copyRangeMethod:
-        description:
-            - The copy range method for the module.
-        type: str
-        required: false
-        default: standard
-    caseSensitiveFS:
-        description:
-            - Whether the filesystem is case sensitive for the module.
-        type: bool
-        required: false
-        default: false
-    junctionsAsDirs:
-        description:
-            - Whether to treat junctions as directories for the module.
-        type: bool
-        required: false
-        default: false
-    syncOwnership:
-        description:
-            - Whether to synchronize ownership for the module.
-        type: bool
-        required: false
-        default: false
-    sendOwnership:
-        description:
-            - Whether to send ownership for the module.
-        type: bool
-        required: false
-        default: false
-    syncXattrs:
-        description:
-            - Whether to synchronize extended attributes for the module.
-        type: bool
-        required: false
-        default: false
-    sendXattrs:
-        description:
-            - Whether to send extended attributes for the module.
-        type: bool
-        required: false
-        default: false
-    xattrFilter:
-        description:
-            - The extended attribute filter for the module.
-        type: dict
-        required: false
-        default: {entries: [], maxSingleEntrySize: 1024, maxTotalSize: 4096}
-
-author:
-    - Rafael Bodill (@rafi)
-'''
-
-EXAMPLES = '''
-# Get/Update folder_defaults
-- name: Get folder_defaults
-  become: yes
-  become_user: syncthing
-  community.syncthing.folder_defaults:
-    host: http://localhost
-    unix_socket: /run/syncthing/syncthing.sock
-    config_file: /var/lib/syncthing/.config/syncthing/config.xml
-    id: "default"
-    label: "default"
-    path: "/"
-    paused: false
-  register: folder_defaults
-'''
-
-RETURN = '''
-folder_defaults:
-    description: The default configuration of the folder after the operation.
-    type: dict
-changed:
-    description: Whether any changes were made.
-    type: bool
-response:
-    description: The API response, in-case of an error.
-    type: dict
-'''
-
-from ansible_collections.community.syncthing.plugins.module_utils.syncthing_api import SyncthingModule
-import json
-
-def deep_equal(a, b):
-    return json.dumps(a, sort_keys=True) == json.dumps(b, sort_keys=True)
-
-def run_module():
-    module_args = dict(
-        id=dict(type='str', required=False),
-        label=dict(type='str', required=False),
-        filesystemType=dict(type='str', required=False, default='basic'),
-        path=dict(type='str', required=False, default='~'),
-        type=dict(type='str', default='sendreceive',
-            choices=['sendreceive', 'sendonly', 'receiveonly']),
-        devices=dict(type='list', required=False, default=[]),
-        rescanIntervalS=dict(type='int', required=False, default=3600),
-        fsWatcherEnabled=dict(type='bool', required=False, default=True),
-        fsWatcherDelayS=dict(type='int', required=False, default=10),
-        ignorePerms=dict(type='bool', required=False, default=False),
-        autoNormalize=dict(type='bool', required=False, default=True),
-        minDiskFree=dict(type='dict', required=False, default=dict(value=1, unit='%')),
-        versioning=dict(type='dict', required=False,
-            default=dict(type='', params={}, cleanupIntervalS=3600, fsPath='', fsType='basic')),
-        copiers=dict(type='int', required=False, default=0),
-        pullerMaxPendingKiB=dict(type='int', required=False, default=0),
-        hashers=dict(type='int', required=False, default=0),
-        order=dict(type='str', required=False, default='random'),
-        ignoreDelete=dict(type='bool', required=False, default=False),
-        scanProgressIntervalS=dict(type='int', required=False, default=0),
-        pullerPauseS=dict(type='int', required=False, default=0),
-        maxConflicts=dict(type='int', required=False, default=10),
-        disableSparseFiles=dict(type='bool', required=False, default=False),
-        disableTempIndexes=dict(type='bool', required=False, default=False),
-        paused=dict(type='bool', required=False, default=False),
-        weakHashThresholdPct=dict(type='int', required=False, default=25),
-        markerName=dict(type='str', required=False, default='.stfolder'),
-        copyOwnershipFromParent=dict(type='bool', required=False, default=False),
-        modTimeWindowS=dict(type='int', required=False, default=0),
-        maxConcurrentWrites=dict(type='int', required=False, default=2),
-        disableFsync=dict(type='bool', required=False, default=False),
-        blockPullOrder=dict(type='str', required=False, default='standard'),
-        copyRangeMethod=dict(type='str', required=False, default='standard'),
-        caseSensitiveFS=dict(type='bool', required=False, default=False),
-        junctionsAsDirs=dict(type='bool', required=False, default=False),
-        syncOwnership=dict(type='bool', required=False, default=False),
-        sendOwnership=dict(type='bool', required=False, default=False),
-        syncXattrs=dict(type='bool', required=False, default=False),
-        sendXattrs=dict(type='bool', required=False, default=False),
-        xattrFilter=dict(type='dict', required=False,
-            default=dict(entries=[], maxSingleEntrySize=1024, maxTotalSize=4096)),
-    )
-
-    module = SyncthingModule(
-        api_url='/rest/config/defaults/folder',
-        argument_spec=module_args,
-    )
-
-    current_config = module.get_call()
-
-    module_args_keys_list = list(module_args.keys())
-
-    changes = {}
-
-    for key, value in module.params.items():
-        # Check if the key is in module_args_keys_list
-        if key in module_args_keys_list:
-            # Check if the value is not None
-            if value is not None:
-                # Check if the value is different from the current_config
-                if not deep_equal(value, current_config.get(key)):
-                    # If all conditions are met, add the key-value pair to changes
-                    changes[key] = value
-
-    if module.check_mode or len(changes.keys()) == 0:
-        module.result['folder_defaults'] = current_config
-        module.exit_json()
-
-    module.patch_call(data=module.params)
-    module.result['folder_defaults'] = module.get_call()
-    module.result['changed'] = True
-    module.result['changes'] = changes
-    module.exit_json()
-
-def main():
-    run_module()
-
-if __name__ == '__main__':
-    main()

collection/plugins/modules/folders.py

@@ -1,89 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-
-# Copyright: (c) 2018, Rafael Bodill <justrafi at google mail>
-# Copyright: (c) 2020, Borjan Tchakaloff <first name at last name dot fr>
-# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
-
-ANSIBLE_METADATA = {
-    'metadata_version': '1.1',
-    'status': ['preview'],
-    'supported_by': 'community'
-}
-
-DOCUMENTATION = '''
----
-module: syncthing_folders
-
-short_description: Retrieve Syncthing folders
-
-version_added: "2.7"
-
-description:
-    - "This module retrieves the list of folders from Syncthing"
-
-options:
-    host:
-        description:
-            - Host to connect to, including port
-        default: http://127.0.0.1:8384
-    unix_socket:
-        description:
-            - Use this unix socket instead of TCP
-        required: false
-    config_file:
-        description:
-            - Path to the Syncthing configuration file for automatic
-              discovery (`api_key`). Note that the running user needs read
-              access to the file.
-        required: false
-    timeout:
-        description:
-            - The socket level timeout in seconds
-        default: 30
-
-author:
-    - Rafael Bodill (@rafi)
-'''
-
-EXAMPLES = '''
-# Get folders
-- name: Get folders
-  become: yes
-  become_user: syncthing
-  community.syncthing.folders:
-    host: http://localhost
-    unix_socket: /run/syncthing/syncthing.sock
-    config_file: /var/lib/syncthing/.config/syncthing/config.xml
-  register: folders
-'''
-
-RETURN = '''
-folders:
-    description: The list of folders retrieved from Syncthing.
-    type: dict
-response:
-    description: The API response, in-case of an error.
-    type: dict
-'''
-
-from ansible_collections.community.syncthing.plugins.module_utils.syncthing_api import SyncthingModule
-
-def run_module():
-    module = SyncthingModule(
-        api_url='/rest/config/folders',
-    )
-
-    folders = {}
-    folders_list = module.get_call()
-    for folder in folders_list:
-        folders[folder['id']] = folder
-    module.result['folders'] = folders
-
-    module.exit_json()
-
-def main():
-    run_module()
-
-if __name__ == '__main__':
-    main()