collection/plugins/module_utils/common.py

@@ -1,36 +0,0 @@
-import json
-
-def deep_equal(a, b):
-    """
-    Compare two data structures for deep equality by converting them to JSON strings.
-
-    Parameters:
-    a (any): First data structure to compare.
-    b (any): Second data structure to compare.
-
-    Returns:
-    bool: True if the two data structures are equal, False otherwise.
-    """
-    return json.dumps(a, sort_keys=True) == json.dumps(b, sort_keys=True)
-
-def get_changes(module_params, module_args_keys_list, current_config):
-    """
-    Function to get changes by comparing module parameters with current configuration.
-
-    Args:
-        module_params (dict): The parameters of the module.
-        module_args_keys_list (list): List of keys to check in module parameters.
-        current_config (dict): The current configuration to compare against.
-
-    Returns:
-        dict: A dictionary containing the changes.
-    """
-    changes = {}
-    
-    for key, value in module_params.items():
-        if key in module_args_keys_list:
-            if value is not None:
-                if not deep_equal(value, current_config.get(key)):
-                    changes[key] = value
-    
-    return changes

collection/plugins/modules/device_defaults.py

@@ -151,7 +151,10 @@ response:
 '''
 
 from ansible_collections.community.syncthing.plugins.module_utils.syncthing_api import SyncthingModule
-from ansible_collections.community.syncthing.plugins.module_utils.common import get_changes
+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(
@@ -184,8 +187,17 @@ def run_module():
 
     module_args_keys_list = list(module_args.keys())
 
-     # Using get_changes function to determine what has changed
+    changes = {}
-    changes = get_changes(module.params, current_config)
+
+    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['device_defaults'] = current_config

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()