ansible-modules-syncthing/collection/plugins/modules/device.py

274 lines
8.5 KiB
Python
Raw Normal View History

2018-11-28 20:22:58 +01:00
#!/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>
2018-11-28 20:22:58 +01:00
# 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_device
short_description: Manage Syncthing devices
version_added: "2.7"
description:
- "This is my longer description explaining my sample module"
options:
id:
description:
- This is the unique id of this new device
required: true
name:
description:
- The name for this new device
required: false
host:
description:
- Host to connect to, including port
default: http://127.0.0.1:8384
2024-04-22 09:11:11 +02:00
unix_socket:
description:
- Use this unix socket instead of TCP
required: false
2018-11-28 20:22:58 +01:00
api_key:
description:
- API key to use for authentication with host.
If not provided, will try to auto-configure from filesystem.
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
2018-11-28 20:22:58 +01:00
timeout:
description:
- The socket level timeout in seconds
default: 30
state:
description:
- Use present/absent to ensure device is added, or not.
default: present
choices: ['absent', 'present', 'paused']
author:
- Rafael Bodill (@rafi)
'''
EXAMPLES = '''
# Add a device to share with
- name: Add syncthing device
syncthing_device:
id: 1234-1234-1234-1234
name: my-server-name
'''
RETURN = '''
response:
description: The API response, in-case of an error.
type: dict
'''
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_URI = "/rest/config/devices"
2018-11-28 20:22:58 +01:00
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, unix_socket=None, device=None):
url = '{}{}{}{}'.format(
host,
SYNCTHING_API_URI,
'/' if device else '',
device if device else '')
2018-11-28 20:22:58 +01:00
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)
2018-11-28 20:22:58 +01:00
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.")
# Fetch Syncthing configuration
def remote_config(module, method='GET', config=None, result=None, device=None,
missing_ok=False):
unix_socket = None
if 'unix_socket' in module.params:
unix_socket = module.params['unix_socket']
url, headers = make_headers(
host=module.params['host'],
unix_socket=unix_socket,
api_key= module.params['api_key'],
device=device)
data = config
if config:
headers['Content-Type'] = 'application/json'
data = json.dumps(config)
if not result:
result = {}
resp, info = fetch_url(
module, url=url, unix_socket=unix_socket,
data=data, headers=headers,
method=method, timeout=module.params['timeout'])
if info:
2018-11-28 20:22:58 +01:00
result['response'] = info
else:
module.fail_json(msg='Error occured while calling host', **result)
if info['status'] not in [200, 404]:
2018-11-28 20:22:58 +01:00
module.fail_json(msg='Error occured while calling host', **result)
if info['status'] == 404:
if missing_ok:
return {}
else:
module.fail_json(msg='Error occured while calling host', **result)
2018-11-28 20:22:58 +01:00
try:
content = resp.read()
2024-04-22 10:20:30 +02:00
except AttributeError:
2018-11-28 20:22:58 +01:00
result['content'] = info.pop('body', '')
module.fail_json(msg='Error occured while reading response', **result)
2024-04-22 10:20:30 +02:00
try:
return json.loads(content)
except json.decoder.JSONDecodeError:
return {'content': content}
2018-11-28 20:22:58 +01:00
def get_device(module, device=None):
return remote_config(module, missing_ok=True, device=device)
def delete_device(module, device, result=None):
return remote_config(module, method='DELETE', device=device, result=result)
2018-11-28 20:22:58 +01:00
# Post the new configuration to Syncthing API
def post_device(module, config, result=None, device=None):
return remote_config(module, method='POST', config=config, result=result,
device=device)
def put_device(module, config, result=None, device=None):
return remote_config(module, method='PUT', config=config, result=result,
device=device)
def patch_device(module, config, result=None, device=None):
return remote_config(module, method='PATCH', config=config, result=result,
device=device)
2018-11-28 20:22:58 +01:00
# Returns an object of a new device
def create_device(params):
device = {
'addresses': [
'dynamic'
],
'allowedNetworks': [],
'autoAcceptFolders': False,
'certName': '',
'compression': 'metadata',
'deviceID': params['id'],
'ignoredFolders': [],
'introducedBy': '',
'introducer': False,
'maxRecvKbps': 0,
'maxSendKbps': 0,
'name': params['name'],
'paused': True if params['state'] == 'paused' else False,
'pendingFolders': [],
'skipIntroductionRemovals': False
}
return device
def run_module():
# module arguments
module_args = url_argument_spec()
module_args.update(dict(
id=dict(type='str', required=True),
name=dict(type='str', required=False),
host=dict(type='str', default='http://127.0.0.1:8384'),
2024-04-22 09:15:34 +02:00
unix_socket=dict(type='str', required=False),
2018-11-28 20:22:58 +01:00
api_key=dict(type='str', required=False, no_log=True),
config_file=dict(type='str', required=False),
2018-11-28 20:22:58 +01:00
timeout=dict(type='int', default=30),
state=dict(type='str', default='present',
2024-04-22 16:54:40 +02:00
choices=['absent', 'present', 'paused']),
2018-11-28 20:22:58 +01:00
))
# seed the result dict in the object
result = {
"changed": False,
"response": None,
}
# the AnsibleModule object will be our abstraction working with Ansible
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=True
)
if module.params['state'] != 'absent' and not module.params['name']:
module.fail_json(msg='You must provide a name when creating', **result)
if module.check_mode:
return result
# Auto-configuration: Try to fetch API key from filesystem
if not module.params['api_key']:
module.params['api_key'] = get_key_from_filesystem(module)
device = get_device(module, module.params['id'])
device_exists = False
if 'deviceID' in device and device['deviceID'] == module.params['id']:
device_exists = True
2024-04-22 16:54:40 +02:00
want_pause = module.params['state'] == 'paused'
2018-11-28 20:22:58 +01:00
if module.params['state'] == 'absent':
if device_exists:
delete_device(module, device=device['deviceID'], result=result)
2018-11-28 20:22:58 +01:00
result['changed'] = True
elif device_exists: # exists but maybe needs changing
if device['paused'] != want_pause:
device['paused'] = want_pause
patch_device(module, config=device, result=result,
device=device['deviceID'])
result['changed'] = True
else: # Doesn't exist but needs to be added
device = create_device(module.params)
post_device(module, config=device, result=result)
result['changed'] = True
2018-11-28 20:22:58 +01:00
module.exit_json(**result)
def main():
run_module()
if __name__ == '__main__':
main()