32 | 
33 |
34 |
33 |
35 | 
36 | 
37 |
38 |
39 | Usage:
40 | add your syncthing devices via a json file or env variables:
41 |
42 | json:
43 | ```
44 | [
45 | {"name" : "device1",
46 | "url": "10.0.0.1:8384",
47 | "api_key": "API_KEY" },
48 | {"name" : "device2",
49 | "url": "10.0.0.2:8384",
50 | "api_key": "API_KEY" }
51 | ]
52 | ```
53 | env variables:
54 | ```
55 | - DEV_NAME_1=device1
56 | - DEV_URL_1=10.0.0.1:8384
57 | - DEV_API_KEY_1=API_KEY
58 | - DEV_NAME_2=device2
59 | - DEV_URL_2=10.0.0.2:8384
60 | - DEV_API_KEY_2=API_KEY
61 | ```
62 |
63 | The default protocol used is http if you require https for a device you'll need to add it to the url
64 |
65 |
66 | # docker-compose example
67 | You can mix both env variables & the device file
68 | ## with env variables
69 | ```
70 | sm2:
71 | image: nwarelab/sm2:latest
72 | container_name: sm2
73 | restart: always
74 | environment:
75 | - DEV_NAME_1=device1
76 | - DEV_URL_1=10.0.0.1:8384
77 | - DEV_API_KEY_1=API_KEY
78 | - DEV_NAME_2=device2
79 | - DEV_URL_2=10.0.0.2:8384
80 | - DEV_API_KEY_2=API_KEY
81 | ports:
82 | - 8456:8456
83 | ```
84 | ## with device files
85 | ```
86 | sm2:
87 | image: nwarelab/sm2:latest
88 | container_name: sm2
89 | restart: always
90 | ports:
91 | - 8456:8456
92 | volumes:
93 | - ./device_list.json:/app/device_list.json
94 | ```
95 |
96 | ## data reporting
97 | By default the application reports some data back for usage statistics.
98 | This is to follow the amount installs and which versions users are running, ...
99 | sm2 will always report what data its sending back.
100 | example of the data
101 | ```
102 | {'ts': 1738466626.1446433, 'hostname': '5251dae16210', 'dev': 1, 'v': '0.1', 'startup': 'True'}
103 | ```
104 | currently this data includes:
105 | - docker container id (this is to keep instances apart in the stats)
106 | - amount off devices configured (just the amount)
107 | - application version
108 |
109 | tl:dr;
110 |
111 | sm² has basic reporting for some statistics. __no personal data__ will ever be sent over, if you want to disable this reporting add the following environment variable. _I would like it if you didn't because I like stats, but I fully understand if you don't_
112 | ```
113 | - DISABLE_REPORTING=true
114 | ```
115 | # Exta settings
116 | | env variable | what it does | default value |
117 | |-----------------------------------------|-------------------------------------|-------------- |
118 | | DISABLE_OFFLINE_DEVICE_BACKGROUND_RETRY | disable the retrying off offline devices in background | false |
119 | | DISABLE_REPORTING | disable the information reporting | false |
120 | | DEVICE_API_TIMEOUT_SEC | timeout value for sm² calls to devices | 0.5 |
121 |
122 |
123 | # FAQ
124 | Q: How would I add devices that are on different networks?
125 | A: I use vpn's to connect my multiple locations common options are tailscale, netbird, twingate, ... (not endorsements)
126 |
127 | # TODO's
128 | - check offline devices in background
129 | - gotify for notifications ?
130 | - figure out healthcheck that has less cpu impact
131 |
132 |
--------------------------------------------------------------------------------
/app.py:
--------------------------------------------------------------------------------
1 |
2 | from syncthing_multi_server.syncthing_muxer import Syncthing_mux
3 | import json
4 | from flask import Flask, jsonify, render_template, request
5 | from env_reader import get_devices_from_env_vriables
6 | import os.path
7 |
8 |
9 | app = Flask(__name__)
10 |
11 | mux = Syncthing_mux()
12 |
13 | # check if there is a device list file
14 | device_list_file_path = "device_list.json"
15 | if os.path.exists(device_list_file_path):
16 | with open (device_list_file_path, "r") as file:
17 | devices = json.load(file)
18 | # add the devices from the json to the mux
19 | mux.add_list_off_devices_dicts(devices)
20 | # add the devices from the env variable to the mux
21 | mux.add_list_off_devices_dicts(get_devices_from_env_vriables())
22 |
23 |
24 |
25 |
26 | @app.route("/")
27 | def root():
28 | # basic html page with an overview off all the configured devices
29 | # default refresh only the known online devices
30 | # but if we get a ?load=full we recheck the offline devices
31 | retest_offline_devices_if_requested()
32 | if request.args.get("thread") == "no":
33 | res = mux.get_full_device_list_status()
34 | else:
35 | res = mux.get_full_device_list_status_threaded()
36 | offline_device_count = mux.get_offline_device_count()
37 | offine_device_names = mux.get_offline_device_names()
38 | last_checked_offline = mux.get_how_long_ago_we_checked_offline_devices_in_human()
39 | return render_template('index.html', status = res, offline_count= offline_device_count, offline_names = offine_device_names, last_checked_offline = last_checked_offline)
40 |
41 | @app.route("/retry_offline_devices")
42 | def retry_offline_devices():
43 | res = mux.retest_the_offline_devices()
44 | return jsonify(res)
45 |
46 | @app.route("/api/status")
47 | def api_status():
48 | retest_offline_devices_if_requested()
49 |
50 | # return the status off all devices to as a json result
51 | return mux.get_full_device_list_status()
52 |
53 | @app.route("/api/devices_not_fully_synced")
54 | def api_devices_not_fully_synced():
55 | return mux.get_list_off_devices_that_are_not_fully_synced()
56 |
57 | @app.route("/ping")
58 | def ping():
59 | return jsonify("ello")
60 |
61 |
62 | # send "metrics" home on startup
63 | # no reason to trigger this yourself
64 | # Please don't spam this. :) thanks
65 | @app.route("/report")
66 | def report_data(startup = False):
67 | # some cool 'magic' which allows us to run this function before the app is fully loaded
68 | with app.app_context():
69 | if os.environ.get("DISABLE_REPORTING", "false").lower() != "true":
70 | import time, socket, requests
71 | data= {}
72 | data["ts"]= time.time()
73 | #aware that this will only give contianer id but thats what i want.
74 | data["hostname"] = socket.gethostname()
75 | # amount off devices
76 | data["dev"]= mux.get_total_device_count()
77 | # app version
78 | data["v"]= os.environ.get("SM2_VERSION", "0")
79 | # is this the startup report or not
80 | data["startup"]= startup
81 | try:
82 | requests.post("https://private-sm2monitor.onrender.com/report",json=data)
83 | except Exception:
84 | print("stats reporting failed")
85 | return jsonify(data)
86 | return jsonify("user requested no reporting so we will not")
87 |
88 |
89 | def retest_offline_devices_if_requested():
90 | if request.args.get("load") == "full":
91 | mux.retest_the_offline_devices()
92 |
93 | def remove_cron_jobs_if_requested():
94 | print("cleaning cron jobs if requested")
95 | if os.environ.get("DISABLE_REPORTING", "false").lower() == "true":
96 | # the user requested no reporting so we will delete the cron job that would trigger that reporting.
97 | report_path = "/etc/periodic/daily/report"
98 | if os.path.exists("/etc/periodic/daily/report"):
99 | print("deleting daily report cron script")
100 | os.remove(report_path)
101 | else:
102 | print(f"{report_path} not found or already deleted")
103 | if os.environ.get("DISABLE_OFFLINE_DEVICE_BACKGROUND_RETRY", "false").lower() == "true":
104 | # user asked for no background retry off the offline devices
105 | retry_offline_devices_path = "/etc/periodic/hourly/retry_offline_devices"
106 | if os.path.exists(retry_offline_devices_path):
107 | print("deleting hourly offline device retry cron")
108 | os.remove(retry_offline_devices_path)
109 | else:
110 | print(f"{retry_offline_devices_path} not found or already deleted")
111 |
112 |
113 | def start_cron_daemon():
114 | import subprocess
115 | subprocess.run("crond")
116 | print("Background cron started")
117 |
118 | if __name__ == '__main__':
119 | app.run()
120 |
121 | report_data(startup=True)
122 | remove_cron_jobs_if_requested()
123 | start_cron_daemon()
124 | print("sm² is loaded and ready")
125 | print("-----------------------------")
126 | print(" ###### ## ## ####### ")
127 | print("## ## ### ### ## ## ")
128 | print("## #### #### ## ")
129 | print(" ###### ## ### ## ####### ")
130 | print(" ## ## ## ## ")
131 | print("## ## ## ## ## ")
132 | print(" ###### ## ## ######### ")
--------------------------------------------------------------------------------
/cron/daily/report:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | #report to home
3 | #It looks like here we are ignoring if the user has configured whether or to do the reporting.
4 | #The users decision is captured by the webserver.
5 | #Future goal is to remove this cron job when the reporting is disable by the user
6 | echo doing the report call
7 | wget http://127.0.0.1:8456/report -O /dev/null
--------------------------------------------------------------------------------
/cron/hourly/retry_offline_devices:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | # retry offline devices
4 | wget http://127.0.0.1:8456/retry_offline_devices -O /dev/null
--------------------------------------------------------------------------------
/env_reader.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 |
4 | def get_devices_from_env_vriables():
5 | print("checking env variables for device configs")
6 | count = 1
7 | running = True
8 | devices = list()
9 | while (running):
10 |
11 | name= os.environ.get(f"DEV_NAME_{count}", None)
12 | if name == None:
13 | break
14 | url= os.environ.get(f"DEV_URL_{count}", None)
15 | api_key= os.environ.get(f"DEV_API_KEY_{count}", None)
16 | # checking if all keys are present is done when devices are added to the mux
17 |
18 | # got all the vars for this round to lets add them
19 | devices.append({"name": name, "url": url, "api_key": api_key})
20 |
21 | count += 1
22 |
23 | return devices
24 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | flask
2 | requests
3 | gunicorn
--------------------------------------------------------------------------------
/screenshots/offline_device.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nware-lab/sm2/544fd4fc7178b51e1fbe688f628906c062b5c59d/screenshots/offline_device.png
--------------------------------------------------------------------------------
/screenshots/overview.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nware-lab/sm2/544fd4fc7178b51e1fbe688f628906c062b5c59d/screenshots/overview.png
--------------------------------------------------------------------------------
/screenshots/pending_device_and_folder.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nware-lab/sm2/544fd4fc7178b51e1fbe688f628906c062b5c59d/screenshots/pending_device_and_folder.png
--------------------------------------------------------------------------------
/syncthing_multi_server/syncthing.py:
--------------------------------------------------------------------------------
1 | import requests
2 | import json
3 | import os
4 |
5 | '''
6 | Setup call timeout based on environment variable if requested by the user
7 | '''
8 | timeout_default_value = 0.5
9 | timeout = timeout_default_value
10 | timeout_env_var_name="DEVICE_API_TIMEOUT_SEC"
11 |
12 | if timeout_env_var_name in os.environ:
13 | try:
14 | input=os.environ.get(timeout_env_var_name, timeout_default_value)
15 | timeout = float(input)
16 | print(f"{timeout_env_var_name} set to {timeout} seconds")
17 | except ValueError:
18 | print(f"error casting requested {timeout_env_var_name} value got : {input} \nreverting back to default value 0.5 s")
19 | # likely an unneeded line but it will one be executed on startup and keeps this readable
20 | timeout=timeout_default_value
21 |
22 |
23 | class Syncthing_device_status:
24 | """ Class for carrying the status off a syncthing device """
25 | def __init__(self, instance_name, url):
26 | self.name = instance_name
27 | self.url = url
28 | self.sync_completion= None
29 | self.errors= None
30 | self.local_changed_files = None
31 | self.folder_count = 0
32 | self.device_count = 0
33 |
34 |
35 |
36 |
37 | class Syncthing:
38 | """ Class representing a Syncthing device """
39 | folder_list_simplified = None
40 | folder_list = None
41 |
42 | def __init__(self,name, url, api_key):
43 | self.name = name
44 | self.baseurl = url
45 | self.api_key= api_key
46 |
47 |
48 | def get_syncthing_device_status(self) -> dict:
49 | device_status = Syncthing_device_status(instance_name=self.name, url=self.baseurl)
50 | device_status.errors = self.system_errors()
51 | device_status.sync_completion = self.system_sync_completion_level()["completion"]
52 | device_status.local_changed_files = self.list_folders_that_have_local_changes()
53 | device_status.folder_count = len(self.list_folders_simplified())
54 | device_status.device_count = len(self.list_devices())
55 | device_status.pending_folders = self.list_pending_folders_labels_for_device()
56 | device_status.pending_devices = self.list_pending_devices_labels_for_device()
57 |
58 |
59 | return device_status
60 |
61 | def _request_builder(self,path:str):
62 | # helper function to keep the rest of the code cleaner
63 | # short timeout because if we in 0.5 sec don't have our response something is wrong and we aren't going to wait forever
64 | # users asked for a configurable timeout, which we get from env variable: default value is 0.5s
65 | return requests.get(self.baseurl + path, headers = {'Authorization': f'Bearer {self.api_key}'},timeout=timeout)
66 |
67 | def healthcheck(self):
68 | # https://docs.syncthing.net/rest/noauth-health-get.html
69 | r = self._request_builder('rest/noauth/health')
70 | return r.json()
71 |
72 | def ping(self):
73 | # https://docs.syncthing.net/rest/system-ping-get.html
74 | r = self._request_builder('rest/system/ping')
75 | if r.status_code != 200:
76 | raise ConnectionError(f"Could not connect to client {self.name}")
77 | return r.json()
78 |
79 | def list_folders(self):
80 | # https://docs.syncthing.net/rest/config.html#rest-config-folders-rest-config-devices
81 | r = self._request_builder('rest/config/folders')
82 | self.folder_list =r.json()
83 | return r.json()
84 |
85 | def list_folders_simplified(self):
86 | js = self.list_folders()
87 |
88 | folder_dict = dict()
89 | # only keep the keys we are interested in
90 | for item in js:
91 | folder_dict[item["label"]]= item["id"]
92 | self.folder_list_simplified = folder_dict
93 | return folder_dict
94 |
95 |
96 | def system_status(self):
97 | # https://docs.syncthing.net/rest/system-status-get.html
98 | r = self._request_builder('rest/system/status')
99 | return r.json()
100 |
101 | def system_errors(self):
102 | # https://docs.syncthing.net/rest/folder-errors-get.html
103 | r = self._request_builder('rest/system/error')
104 | if r.json() == {'errors': None}:
105 | return None
106 | return r.json()
107 |
108 | def system_logs(self):
109 | # https://docs.syncthing.net/rest/system-log-get.html
110 | r = self._request_builder('rest/system/log')
111 | return r.json()
112 |
113 | def system_sync_completion_level(self):
114 | # https://docs.syncthing.net/rest/db-completion-get.html
115 | r = self._request_builder(f'rest/db/completion')
116 | return r.json()
117 |
118 | def list_folders_that_are_incomplete(self):
119 | folders_with_non_complete_status = list()
120 | for folder in self.folder_list:
121 | result = self.list_missing_files_for_folder(folder_id=folder["id"])
122 | return result
123 |
124 | def list_devices(self):
125 | # https://docs.syncthing.net/rest/config.html#rest-config-folders-rest-config-devices
126 | r = self._request_builder("rest/config/devices")
127 | return r.json()
128 |
129 |
130 | def list_local_changes_for_folder(self, folder_id):
131 | # https://docs.syncthing.net/rest/db-localchanged-get.html
132 |
133 | # only check for non paused folders
134 | r = self._request_builder(f"rest/db/localchanged?folder={folder_id}")
135 | # print(f"folderid = {folder_id} \n response\n{r}")
136 | return r.json()
137 |
138 | def list_folders_that_have_local_changes(self):
139 | folders_with_local_changes = dict()
140 | if self.folder_list == None:
141 | self.list_folders()
142 | if len(self.folder_list) == 0:
143 | return None
144 | for folder in self.folder_list:
145 | if folder["type"] == "receiveonly" and folder["paused"] == False :
146 |
147 | # print(folder["id"] + " " + folder["label"])
148 | result = self.list_local_changes_for_folder(folder_id=folder["id"])
149 | # print(result)
150 | result_count =len(result["files"])
151 | if result_count > 0:
152 | folders_with_local_changes[folder["label"]] = result_count
153 | else:
154 | # print(f"skipping {folder['id']} as its either not reeive only or is paused")
155 | pass
156 |
157 | if len(folders_with_local_changes) == 0:
158 | return None
159 |
160 | return folders_with_local_changes
161 |
162 | def list_pending_folders_for_device(self):
163 | r = self._request_builder("rest/cluster/pending/folders")
164 |
165 | return r.json()
166 | def list_pending_devices_for_device(self):
167 | r = self._request_builder("rest/cluster/pending/devices")
168 | return r.json()
169 |
170 | def list_pending_devices_labels_for_device(self):
171 | js = self.list_pending_devices_for_device()
172 | # get jsust the labels from the js
173 | label_list = []
174 | for device in js:
175 | label_list.append(js[device]["name"])
176 | return label_list
177 |
178 |
179 | def list_pending_folders_labels_for_device(self):
180 | js = self.list_pending_folders_for_device()
181 | # get jsust the labels from the js
182 | label_list = []
183 | for folder in js:
184 | if folder != "{}":
185 | # this feels like it could be done more efficient
186 | # TODO make this less iffy
187 | inter_folder = js[folder]["offeredBy"]
188 | device_name = list(inter_folder.keys())[0]
189 | label_list.append(inter_folder[device_name]["label"])
190 |
191 | return label_list
--------------------------------------------------------------------------------
/syncthing_multi_server/syncthing_muxer.py:
--------------------------------------------------------------------------------
1 | from syncthing_multi_server.syncthing import Syncthing
2 | import time
3 |
4 | import threading
5 | import concurrent.futures
6 |
7 | """ class that gathers the info from all the configured syncthing devices """
8 |
9 |
10 | class Syncthing_mux:
11 | # type hint
12 | device_list : [Syncthing]
13 |
14 | def __init__(self):
15 | self.device_list = []
16 | self.offline_device_list = []
17 | self.offline_last_checked = time.time()
18 |
19 | def add_syncthing_device_to_mux(self, name, url, api_key):
20 | # cleanup the url
21 | if url.startswith("http") == False:
22 | url = f"http://{url}"
23 | # if no port is set we add the default syncthing ui port
24 | # but when a url starts with https, we expect the user to know what they are doing
25 | # and they will likely not be using the default webui port anymore
26 | if ':' not in url[-7:] and not url.startswith("https"):
27 | url = f"{url}:8384"
28 | if url.endswith("/") == False:
29 | url= f"{url}/"
30 | device = Syncthing(name, url, api_key)
31 | # check if the device is up
32 | try:
33 | device.healthcheck()
34 | except Exception as ex:
35 | # not perfect that we catch just every type off exception but for now it will do.
36 | print (f"error while connecting with device: {name}, this indicates that the protocol, ip or port is wrong, this test does not use the api key")
37 | print(f"{name} connection error : {ex}")
38 | self.add_device_to_the_offline_list(device=device)
39 | #this device errored so we don't add it to the list return to finish the function
40 | return
41 | # ping and also check if we have a working api key
42 | try:
43 | device.ping()
44 | except Exception as ex:
45 | print (f"error while connecting with device: {name} using its api key this indicates that the api key is wrong. ")
46 | self.add_device_to_the_offline_list(device=device)
47 | # print(ex.with_traceback())
48 | #this device errored so we don't add it to the list return to finish the function
49 | return
50 | self.device_list.append(device)
51 |
52 | def add_list_off_devices_dicts(self, list):
53 | for device in list:
54 | # check if all params are present
55 | if "name" not in device:
56 | print("device added that is missing a name")
57 | return
58 | name = device["name"]
59 | if "url" not in device:
60 | print(f"device {name} is missing url")
61 | return
62 | url = device["url"]
63 | if "api_key" not in device:
64 | print(f"device {name} is missing an api_key")
65 | return
66 | api_key = device["api_key"]
67 | self.add_syncthing_device_to_mux(name= name,
68 | api_key= api_key,
69 | url=url)
70 |
71 | def add_device_to_the_offline_list(self, device:Syncthing):
72 | # sounds stupid to keep a device that is not online.
73 | # but some clients are not online 24/7 ex. mobile devices, personal computors, unstable connections, ...
74 | # so we keep these devices so that we can try to reach them in the future
75 |
76 | self.offline_device_list.append(device)
77 | def move_device_from_online_to_offline(self, device:Syncthing):
78 | #print(f"moving {device} to the offline list)")
79 | self.add_device_to_the_offline_list(device)
80 | self.device_list.remove(device)
81 |
82 | def retest_the_offline_devices(self):
83 | # remember when we last did this
84 | self.offline_last_checked = time.time()
85 |
86 | # we try if any of the offline devices is up now
87 | for device in self.offline_device_list:
88 | # we pop the device from the list as we are positive and assume that it will be online now.
89 | # pop 0 to take from the top as we always add to the bottom.
90 | # otherwise if all these are still offline we could check the last one in this list for the amount off offline devices in the list.
91 | dev = self.offline_device_list.pop(0)
92 | self.add_syncthing_device_to_mux(name=dev.name,url=dev.baseurl, api_key=dev.api_key)
93 |
94 | def get_how_long_ago_we_checked_offline_devices_seconds(self) -> int:
95 | return int(time.time() - self.offline_last_checked)
96 | def get_how_long_ago_we_checked_offline_devices_in_human(self) -> str:
97 | sec = self.get_how_long_ago_we_checked_offline_devices_seconds()
98 | if sec < 60:
99 | return f"{sec} second{'s' if sec > 1 else ''} ago"
100 | elif sec < 3600: # Less than an hour
101 | min = round(sec / 60)
102 | return f"{min} minute{'s' if min > 1 else ''} ago"
103 | elif sec < 86400: # Less than a day
104 | hours = round(sec / 3600)
105 | return f"{hours} hour{'s' if hours > 1 else ''} ago"
106 | else:
107 | days = round(sec / 86400)
108 | return f"{days} day{'s' if days > 1 else ''} ago"
109 |
110 |
111 |
112 | def del_none(self, d):
113 | # cleanup dict to remove keys that have None values
114 | for key, value in list(d.items()):
115 | if value is None:
116 | del d[key]
117 | elif isinstance(value, dict):
118 | self.del_none(value)
119 | return d
120 |
121 | def get_full_device_list_status(self):
122 | all_statuses = list()
123 |
124 | # before 800~ ms response for 6 devices
125 | #TODO multithread this
126 |
127 | for device in self.device_list:
128 | try:
129 | status = device.get_syncthing_device_status()
130 | # removing all keys that have null values
131 | all_statuses.append(self.del_none(status.__dict__))
132 | except Exception as ex: # todo don't just catch all exceptions
133 | self.move_device_from_online_to_offline(device=device)
134 |
135 |
136 | return all_statuses
137 |
138 | def get_full_device_list_status_threaded(self):
139 | all_statuses = list()
140 |
141 | with concurrent.futures.ThreadPoolExecutor() as executor:
142 | futures = [executor.submit(self.thread_worker_get_device_status, device) for device in self.device_list] # create the threads and assign them function and arguments
143 |
144 | for future in concurrent.futures.as_completed(futures): # as_completed returns the results when the threads are done
145 | try:
146 | result = future.result() # Get the result from the thread
147 | all_statuses.append(result)
148 | except Exception as e:
149 | print(f"error when checking for statuses with threads {e}")
150 | print(f"because we have an error in the threaded way likely a device that has gone ofline, we switch back to the non threaded check")
151 | return self.get_full_device_list_status()
152 |
153 |
154 | return all_statuses
155 |
156 | def thread_worker_get_device_status(self, device:Syncthing):
157 | status = device.get_syncthing_device_status()
158 | return self.del_none(status.__dict__)
159 |
160 | def get_list_off_devices_that_are_not_fully_synced(self) -> []:
161 | full_status = self.get_full_device_list_status()
162 | unfinished_syncs = []
163 | for device in full_status:
164 | if device["sync_completion"] < 100 :
165 | unfinished_syncs.append({"name": device["name"], "sync_completion" : device["sync_completion"]})
166 | return unfinished_syncs
167 |
168 |
169 | def get_total_device_count(self) -> int:
170 | return len(self.offline_device_list) + len(self.device_list)
171 |
172 | def get_offline_device_count(self) -> int:
173 | return len(self.offline_device_list)
174 | def get_offline_device_names(self) -> [str]:
175 | name_list = []
176 | for device in self.offline_device_list:
177 | name_list.append(device.name)
178 | return name_list
--------------------------------------------------------------------------------
/templates/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
36 |
37 |
108 |
109 | Device{% if status |length > 1 %}s{% endif %} ({{ status |length }})
110 |
111 |
112 |
113 | {%- for device in status %}
114 |
185 |
186 |
187 |
188 |
--------------------------------------------------------------------------------
115 |
116 |
167 | {% endfor %}
168 | {% if offline_count > 0 %}
169 | 
{{device.name}}
117 |
118 | {% if device.sync_completion == 100 %}
119 | Up to Date
120 | {% else %}
121 | Syncing {{device.sync_completion | int() }}%
122 | {% endif %}
123 | {{device.folder_count}} folders - {{device.device_count}} devices
124 |
125 |
126 | {% if device.errors is defined %}
127 | {{device.errors}}
128 | {% endif %}
129 |
130 | {% if device.local_changed_files is defined %}
131 | Folders with local changes:
132 | {% if device.local_changed_files.items()| length > 0 %}
133 |
134 | {%- for folder, count in device.local_changed_files.items() %}
135 | - {{folder}}: {{count}} file{% if count > 1 %}s{% endif %}
136 | {% endfor %}
137 |
138 | {% else %}
139 | No file conflicts
140 | {% endif %}
141 | {% endif %}
142 |
143 |
144 | {% if device.pending_devices is defined and device.pending_devices| length > 0 %}
145 | Pending device{% if device.pending_devices|length > 1 %}s{% endif %}:
146 |
147 | {%- for device in device.pending_devices %}
148 | - {{device}}
149 | {% endfor %}
150 |
151 | {% endif %}
152 |
153 |
154 | {% if device.pending_folders is defined and device.pending_folders| length > 0 %}
155 | Pending folder{% if device.pending_folders|length > 1 %}s{% endif %}:
156 |
157 | {%- for folder in device.pending_folders %}
158 | - {{folder}}
159 | {% endfor %}
160 |
161 | {% endif %}
162 |
163 |
164 |
165 |
166 |
Up to Date
120 | {% else %}
121 | Syncing {{device.sync_completion | int() }}%
122 | {% endif %}
123 | {{device.folder_count}} folders - {{device.device_count}} devices
124 |
125 |
126 | {% if device.errors is defined %}
127 | {{device.errors}}
128 | {% endif %}
129 |
130 | {% if device.local_changed_files is defined %}
131 | Folders with local changes:
132 | {% if device.local_changed_files.items()| length > 0 %}
133 | -
134 | {%- for folder, count in device.local_changed_files.items() %}
135 |
- {{folder}}: {{count}} file{% if count > 1 %}s{% endif %} 136 | {% endfor %} 137 |
No file conflicts
140 | {% endif %}
141 | {% endif %}
142 |
143 |
144 | {% if device.pending_devices is defined and device.pending_devices| length > 0 %}
145 | Pending device{% if device.pending_devices|length > 1 %}s{% endif %}:
146 | -
147 | {%- for device in device.pending_devices %}
148 |
- {{device}} 149 | {% endfor %} 150 |
Pending folder{% if device.pending_folders|length > 1 %}s{% endif %}:
156 | -
157 | {%- for folder in device.pending_folders %}
158 |
- {{folder}} 159 | {% endfor %} 160 |
170 |
183 | {% endif %}
184 | Offline Devices
171 |
172 | {{offline_count}} offline device{% if offline_count > 1 %}s{% endif %}
173 |
174 | Checked {{last_checked_offline}}
175 |
176 |
177 | {%- for device_name in offline_names %}
178 | ● {{device_name}}
179 | {% endfor %}
180 |
181 |
182 |
{{offline_count}} offline device{% if offline_count > 1 %}s{% endif %}
173 |
174 | Checked {{last_checked_offline}}
175 |
176 | -
177 | {%- for device_name in offline_names %}
178 |
- ● {{device_name}}