open-source-mirrors
/
syncarr
mirror of https://github.com/syncarr/syncarr
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix merge conflict

Browse Source
pull/80/head 1.13.0
Junkbite 4 years ago
parent 8ee7c3457f 2c38787852
commit e57aa9a330
3 changed files with 111 additions and 116 deletions
Show Stats Download Patch File Download Diff File

51
README.md
Unescape View File

@ -1,23 +1,25 @@
# Syncarr # Syncarr
Syncs two Radarr/Sonarr/Lidarr servers through the web API. Useful for syncing a 4k Radarr/Sonarr instance to a 1080p Radarr/Sonarr instance. Syncs two Radarr/Sonarr/Lidarr servers through the web API. Useful for syncing a 4k Radarr/Sonarr instance to a 1080p Radarr/Sonarr instance.
* Supports Radarr/Sonarr version 2 and 3. * Supports Radarr/Sonarr v3.
* Can sync by `profile` name or `profile_id` * Can sync by `profile` name or `profile_id`
* Filter what media gets synced by `profile` name or `profile_id` * Filter what media gets synced by `profile` name or `profile_id`
* Supports Docker for multiple instances * Supports Docker for multiple instances
* Can set interval for syncing * Can set interval for syncing
* Support two way sync (one way by default) * Support two way sync (one way by default)
* Skip content with missing files (Radarr only) * Skip content with missing files
* Set language profiles (Sonarr v3 only) * Set language profiles
* Filter syncing by content file quality (Radarr only) * Filter syncing by content file quality (Radarr only)
* Filter syncing by tags (Sonarr/Radarr v3 only) * Filter syncing by tags (Sonarr/Radarr)
* Allow for a test run using `test_run` flag (does everything but actually sync) * Allow for a test run using `test_run` flag (does everything but actually sync)
## Configuration ## Configuration
1. Edit the config.conf file and enter your servers URLs and API keys for each server. 1. Edit the config.conf file and enter your servers URLs and API keys for each server.
2. Add the profile name (case insensitive) and movie path for the Radarr instance the movies will be synced to: 2. Add the profile name (case insensitive) and movie path for the Radarr instance the movies will be synced to:
```ini
```ini
[radarrA] [radarrA]
url = https://4k.example.com:443 url = https://4k.example.com:443
key = XXXXX key = XXXXX
@ -28,7 +30,9 @@ Syncs two Radarr/Sonarr/Lidarr servers through the web API. Useful for syncing a
profile = 1080p profile = 1080p
path = /data/Movies # if not given will use RadarrA path for each movie - may not be what you want! path = /data/Movies # if not given will use RadarrA path for each movie - may not be what you want!
``` ```
3. Or if you want to sync two Sonarr instances: 3. Or if you want to sync two Sonarr instances:
```ini ```ini
[sonarrA] [sonarrA]
url = https://4k.example.com:443 url = https://4k.example.com:443
@ -41,6 +45,7 @@ Syncs two Radarr/Sonarr/Lidarr servers through the web API. Useful for syncing a
path = /data/Shows path = /data/Shows
4. Or if you want to sync two Lidarr instances: 4. Or if you want to sync two Lidarr instances:
5.
```ini ```ini
[lidarrA] [lidarrA]
url = https://lossless.example.com:443 url = https://lossless.example.com:443
@ -55,15 +60,16 @@ Syncs two Radarr/Sonarr/Lidarr servers through the web API. Useful for syncing a
**Note** you cannot have a mix of Radarr, Lidarr, or Sonarr config setups at the same time. **Note** you cannot have a mix of Radarr, Lidarr, or Sonarr config setups at the same time.
5. Optional Configuration 6. Optional Configuration
```ini ```ini
[*arrA] [*arrA]
url = http://127.0.0.1:8080 url = http://127.0.0.1:8080
key = XXXXX key = XXXXX
profile_filter = 1080p # add a filter to only sync contents belonging to this profile (can set by profile_filter_id as well) profile_filter = 1080p # add a filter to only sync contents belonging to this profile (can set by profile_filter_id as well)
quality_match = HD- # (Radarr only) regex match to only sync content that matches the set quality (ie if set to 1080p then only movies with matching downloaded quality of 1080p will be synced) quality_match = HD- # (Radarr only) regex match to only sync content that matches the set quality (ie if set to 1080p then only movies with matching downloaded quality of 1080p will be synced)
tag_filter = Horror # (Sonarr/Radarr v3 only) sync movies by tag name (seperate multiple tags by comma (no spaces) ie horror,comedy,action) tag_filter = Horror # (Sonarr/Radarr) sync movies by tag name (seperate multiple tags by comma (no spaces) ie horror,comedy,action)
tag_filter_id = 2 # (Sonarr/Radarr v3 only) sync movies by tag id (seperate multiple tags by comma (no spaces) ie 2,3,4) tag_filter_id = 2 # (Sonarr/Radarr) sync movies by tag id (seperate multiple tags by comma (no spaces) ie 2,3,4)
blacklist = movie-name-12,movie-name-43,432534,8e38819d-71be-9e7d-b41d-f1df91b01d3f # comma seperated list of content slugs OR IDs you want to never sync from A to B (no spaces) blacklist = movie-name-12,movie-name-43,432534,8e38819d-71be-9e7d-b41d-f1df91b01d3f # comma seperated list of content slugs OR IDs you want to never sync from A to B (no spaces)
# the slug is the part of the URL after "/movies/" (for Radarr), "/series/" (for Sonarr), or "/artist/" (for Lidarr) # the slug is the part of the URL after "/movies/" (for Radarr), "/series/" (for Sonarr), or "/artist/" (for Lidarr)
@ -71,15 +77,16 @@ Syncs two Radarr/Sonarr/Lidarr servers through the web API. Useful for syncing a
url = http://127.0.0.1:8080 url = http://127.0.0.1:8080
key = XXXXX key = XXXXX
profile_id = 1 # Syncarr will try to find id from name but you can specify the id directly if you want profile_id = 1 # Syncarr will try to find id from name but you can specify the id directly if you want
language = Vietnamese # can set language for new content added (Sonarr v3 only) (can set by language_id as well) language = Vietnamese # can set language for new content added (Sonarr) (can set by language_id as well)
path = /data/Movies path = /data/Movies
[general] [general]
sync_bidirectionally = 1 # sync from instance A to B **AND** instance B to A sync_bidirectionally = 1 # sync from instance A to B **AND** instance B to A (default 0)
auto_search = 0 # search is automatically started on new content - disable by setting to 0 (default 1) auto_search = 0 # search is automatically started on new content - disable by setting to 0 (default 1)
skip_missing = 1 # content with missing files are skipped on sync - disable by setting to 0 (default 1) (Radarr only) skip_missing = 1 # content with missing files are skipped on sync - disable by setting to 0 (default 1) (Radarr only)
monitor_new_content = 0 # set to 0 to never monitor new content synced or to 1 to always monitor new content synced (default 1) monitor_new_content = 0 # set to 0 to never monitor new content synced or to 1 to always monitor new content synced (default 1)
test_run = 1 # enable test mode - will run through sync program but will not actually sync content test_run = 1 # enable test mode - will run through sync program but will not actually sync content (default 0)
sync_monitor = 1 # if set to 1 will sync if the content is monitored or not to instance B (default 0)
``` ```
**Note** If `sync_bidirectionally` is set to `1`, then instance A will require either `profile_id` or `profile` AND `path` as well **Note** If `sync_bidirectionally` is set to `1`, then instance A will require either `profile_id` or `profile` AND `path` as well
@ -106,7 +113,7 @@ Syncs two Radarr/Sonarr/Lidarr servers through the web API. Useful for syncing a
## Docker Compose ## Docker Compose
This script can run through a docker container with a set interval (default every 5 minutes) This script can run through a docker container with a set interval (default every 5 minutes)
``` ```bash
syncarr: syncarr:
image: syncarr/syncarr:latest image: syncarr/syncarr:latest
container_name: syncarr container_name: syncarr
@ -123,7 +130,7 @@ syncarr:
or or
``` ```bash
syncarr: syncarr:
image: syncarr/syncarr:latest image: syncarr/syncarr:latest
container_name: syncarr container_name: syncarr
@ -140,7 +147,7 @@ syncarr:
or or
``` ```bash
syncarr: syncarr:
image: syncarr/syncarr:latest image: syncarr/syncarr:latest
container_name: syncarr container_name: syncarr
@ -156,17 +163,20 @@ syncarr:
``` ```
--- ---
## Docker ## Docker
For just plain docker (radarr example): For just plain docker (radarr example):
``` ```bash
docker run -it --rm --name syncarr -e RADARR_A_URL=https://4k.example.com:443 -e RADARR_A_KEY=XXXXX -e RADARR_B_URL=http://127.0.0.1:8080 -e RADARR_B_KEY=XXXXX -e RADARR_B_PROFILE=1080p -e RADARR_B_PATH=/data/Movies -e SYNC_INTERVAL_SECONDS=300 syncarr/syncarr docker run -it --rm --name syncarr -e RADARR_A_URL=https://4k.example.com:443 -e RADARR_A_KEY=XXXXX -e RADARR_B_URL=http://127.0.0.1:8080 -e RADARR_B_KEY=XXXXX -e RADARR_B_PROFILE=1080p -e RADARR_B_PATH=/data/Movies -e SYNC_INTERVAL_SECONDS=300 syncarr/syncarr
``` ```
**Notes** ## Notes
* You can also specify the `PROFILE_ID` directly through the `*ARR_A_PROFILE_ID` and `*ARR_B_PROFILE_ID` ENV variables. * You can also specify the `PROFILE_ID` directly through the `*ARR_A_PROFILE_ID` and `*ARR_B_PROFILE_ID` ENV variables.
To filter by profile in docker use `*ARR_A_PROFILE_FILTER` or `*ARR_A_PROFILE_FILTER_ID` ENV variables. (same for `*arr_B` in bidirectional sync) To filter by profile in docker use `*ARR_A_PROFILE_FILTER` or `*ARR_A_PROFILE_FILTER_ID` ENV variables. (same for `*arr_B` in bidirectional sync)
* Language for new content (Sonarr v3 only) can be set by `SONARR_B_LANGUAGE` or `SONARR_B_LANGUAGE_ID` (and `SONARR_B` if bidirectional sync) * Language for new content (Sonarr) can be set by `SONARR_B_LANGUAGE` or `SONARR_B_LANGUAGE_ID` (and `SONARR_B` if bidirectional sync)
* Set bidirectional sync with `SYNCARR_BIDIRECTIONAL_SYNC=1` (default 0) * Set bidirectional sync with `SYNCARR_BIDIRECTIONAL_SYNC=1` (default 0)
* Set disable auto searching on new content with `SYNCARR_AUTO_SEARCH=0` (default 1) * Set disable auto searching on new content with `SYNCARR_AUTO_SEARCH=0` (default 1)
* Set if you want to NOT monitor new content with `SYNCARR_MONITOR_NEW_CONTENT=0` (default 1) * Set if you want to NOT monitor new content with `SYNCARR_MONITOR_NEW_CONTENT=0` (default 1)
@ -174,9 +184,12 @@ To filter by profile in docker use `*ARR_A_PROFILE_FILTER` or `*ARR_A_PROFILE_FI
* Filter by tag names or ids with `*ARR_A_TAG_FILTER` / `*ARR_B_TAG_FILTER` or `*ARR_A_TAG_FILTER_ID` / `*ARR_B_TAG_FILTER_ID` * Filter by tag names or ids with `*ARR_A_TAG_FILTER` / `*ARR_B_TAG_FILTER` or `*ARR_A_TAG_FILTER_ID` / `*ARR_B_TAG_FILTER_ID`
* Enable test mode with `SYNCARR_TEST_RUN` * Enable test mode with `SYNCARR_TEST_RUN`
* add blacklist with `*ARR_A_BLACKLIST` and `**ARR_B_BLACKLIST` * add blacklist with `*ARR_A_BLACKLIST` and `**ARR_B_BLACKLIST`
* sync monitor settings with `SYNCARR_SYNC_MONITOR`
--- ---
## Troubleshooting ## Troubleshooting
If you need to troubleshoot syncarr, then you can either set the log level through the config file: If you need to troubleshoot syncarr, then you can either set the log level through the config file:
```ini ```ini
@ -187,5 +200,7 @@ log_level = 10
Or in docker, set the `LOG_LEVEL` ENV variable. Default is set to `20` (info only) but you can set to `10` to get debug info as well. When pasting debug logs online, **make sure to remove any apikeys and any other data you don't want others to see.** Or in docker, set the `LOG_LEVEL` ENV variable. Default is set to `20` (info only) but you can set to `10` to get debug info as well. When pasting debug logs online, **make sure to remove any apikeys and any other data you don't want others to see.**
--- ---
## Disclaimer ## Disclaimer
Back up your instances before trying this out. I am not responsible for any lost data. Back up your instances before trying this out. I am not responsible for any lost data.

91
config.py
Unescape View File

@ -150,55 +150,26 @@ lidarrB_language_id = get_config_value('LIDARR_B_LANGUAGE_ID', 'language_id', 'l
lidarrB_quality_match = get_config_value('LIDARR_B_QUALITY_MATCH', 'quality_match', 'lidarrB') lidarrB_quality_match = get_config_value('LIDARR_B_QUALITY_MATCH', 'quality_match', 'lidarrB')
lidarrB_blacklist = get_config_value('LIDARR_B_BLACKLIST', 'blacklist', 'lidarrB') lidarrB_blacklist = get_config_value('LIDARR_B_BLACKLIST', 'blacklist', 'lidarrB')
# set to search if config not set
sync_bidirectionally = get_config_value('SYNCARR_BIDIRECTIONAL_SYNC', 'bidirectional', 'general')
if sync_bidirectionally is not None:
try:
sync_bidirectionally = int(sync_bidirectionally)
except ValueError:
sync_bidirectionally = 0
else:
sync_bidirectionally = 0
# set to search if config not set
auto_search = get_config_value('SYNCARR_AUTO_SEARCH', 'auto_search', 'general')
if auto_search is not None:
try:
auto_search = int(auto_search)
except ValueError:
auto_search = 0
else:
auto_search = 1
# set to skip missing if config not set def set_general_option(env_name, config_name, default_value):
skip_missing = get_config_value('SYNCARR_SKIP_MISSING', 'skip_missing', 'general') """gets a general config value"""
if skip_missing is not None: config_value = get_config_value(env_name, config_name, 'general')
try: if config_value is not None:
skip_missing = int(skip_missing) try:
except ValueError: config_value = int(config_value)
skip_missing = 0 except ValueError:
else: config_value = default_value
skip_missing = 1 else:
config_value = default_value
# set to monitor if config not set return config_value
monitor_new_content = get_config_value('SYNCARR_MONITOR_NEW_CONTENT', 'monitor_new_content', 'general')
if monitor_new_content is not None: # get general options
try: sync_bidirectionally = set_general_option('SYNCARR_BIDIRECTIONAL_SYNC', 'bidirectional', default_value=0)
monitor_new_content = int(monitor_new_content) auto_search = set_general_option('SYNCARR_AUTO_SEARCH', 'auto_search', default_value=1)
except ValueError: skip_missing = set_general_option('SYNCARR_SKIP_MISSING', 'skip_missing', default_value=1)
monitor_new_content = 1 monitor_new_content = set_general_option('SYNCARR_MONITOR_NEW_CONTENT', 'monitor_new_content', default_value=1)
else: sync_monitor = set_general_option('SYNCARR_SYNC_MONITOR', 'sync_monitor', default_value=0)
monitor_new_content = 1 is_test_run = set_general_option('SYNCARR_TEST_RUN', 'test_run', default_value=0)
# enable test mode
is_test_run = get_config_value('SYNCARR_TEST_RUN', 'test_run', 'general')
if is_test_run is not None:
try:
is_test_run = int(is_test_run)
except ValueError:
is_test_run = 0
else:
is_test_run = 0
######################################################################################################################## ########################################################################################################################
# setup logger # setup logger
@ -277,8 +248,8 @@ instanceB_tag_filter = ''
instanceB_tag_filter_id = '' instanceB_tag_filter_id = ''
instanceB_blacklist = '' instanceB_blacklist = ''
api_version = '' # we are going to detect what API version we are on api_version = ''
tested_api_version = False # only get api version once
api_content_path = '' # url path to add content api_content_path = '' # url path to add content
api_profile_path = '' # url path to get quality profiles api_profile_path = '' # url path to get quality profiles
@ -317,9 +288,9 @@ if radarrA_url and radarrB_url:
instanceB_quality_match = radarrB_quality_match instanceB_quality_match = radarrB_quality_match
instanceB_blacklist = radarrB_blacklist instanceB_blacklist = radarrB_blacklist
api_version = V2_API_PATH # radarr v2 doesnt have version in api url api_version = V3_API_PATH
api_content_path = 'movie' api_content_path = 'movie'
api_profile_path = 'profile' api_profile_path = 'qualityprofile'
api_status_path = 'system/status' api_status_path = 'system/status'
content_id_key = 'tmdbId' content_id_key = 'tmdbId'
@ -354,7 +325,7 @@ elif sonarrA_url and sonarrB_url:
instanceB_quality_match = sonarrB_quality_match instanceB_quality_match = sonarrB_quality_match
instanceB_blacklist = sonarrB_blacklist instanceB_blacklist = sonarrB_blacklist
api_version = V3_API_PATH # for sonarr try v3 first api_version = V3_API_PATH
api_content_path = 'series' api_content_path = 'series'
api_profile_path = 'qualityprofile' api_profile_path = 'qualityprofile'
api_status_path = 'system/status' api_status_path = 'system/status'
@ -412,14 +383,6 @@ if instanceB_blacklist:
def get_path(instance_url, api_path, key, changed_api_version=False): def get_path(instance_url, api_path, key, changed_api_version=False):
global api_version, api_profile_path global api_version, api_profile_path
if changed_api_version:
api_version = V3_API_PATH
# for sonarr - we check v3 first then v2
if is_sonarr and changed_api_version:
api_version = V2_API_PATH
api_profile_path = 'profile'
logger.debug(DEBUG_LINE) logger.debug(DEBUG_LINE)
logger.debug({ logger.debug({
'instance_url': instance_url, 'instance_url': instance_url,
@ -445,6 +408,11 @@ def get_content_path(instance_url, key):
logger.debug('get_content_path: {}'.format(url)) logger.debug('get_content_path: {}'.format(url))
return url return url
def get_content_put_path(instance_url, key, content_id):
url = get_path(instance_url, f'{api_content_path}/{content_id}', key)
logger.debug('get_content_put_path: {}'.format(url))
return url
def get_language_path(instance_url, key): def get_language_path(instance_url, key):
url = get_path(instance_url, api_language_path, key) url = get_path(instance_url, api_language_path, key)
@ -509,6 +477,7 @@ logger.debug({
'auto_search': auto_search, 'auto_search': auto_search,
'skip_missing': skip_missing, 'skip_missing': skip_missing,
'api_version': api_version, 'api_version': api_version,
'sync_monitor': sync_monitor,
}) })
if not instanceA_url: if not instanceA_url:

81
index.py
Unescape View File

@ -22,15 +22,16 @@ from config import (
instanceB_tag_filter_id, instanceB_tag_filter, instanceB_blacklist, instanceB_tag_filter_id, instanceB_tag_filter, instanceB_blacklist,
content_id_key, logger, is_sonarr, is_radarr, is_lidarr, content_id_key, logger, is_sonarr, is_radarr, is_lidarr,
get_status_path, get_content_path, get_profile_path, get_language_path, get_tag_path, get_status_path, get_content_path, get_profile_path, get_language_path, get_tag_path, get_content_put_path,
is_in_docker, instance_sync_interval_seconds, is_in_docker, instance_sync_interval_seconds,
sync_bidirectionally, auto_search, skip_missing, monitor_new_content, sync_bidirectionally, auto_search, skip_missing, monitor_new_content,
tested_api_version, api_version, V3_API_PATH, is_test_run, api_version, is_test_run, sync_monitor
) )
def get_new_content_payload(content, instance_path, instance_profile_id, instance_url, instance_language_id=None): def get_content_details(content, instance_path, instance_profile_id, instance_url, instance_language_id=None):
"""gets details of a content item"""
global monitor_new_content, auto_search global monitor_new_content, auto_search
images = content.get('images') images = content.get('images')
@ -193,8 +194,8 @@ def get_language_from_id(instance_session, instance_url, instance_key, instance_
def sync_servers(instanceA_contents, instanceB_language_id, instanceB_contentIds, def sync_servers(instanceA_contents, instanceB_language_id, instanceB_contentIds,
instanceB_path, instanceB_profile_id, instanceA_profile_filter_id, instanceB_path, instanceB_profile_id, instanceA_profile_filter_id,
instanceB_session, instanceB_url, instanceB_key, instanceA_quality_match, instanceB_session, instanceB_url, instanceB_key, instanceA_quality_match,
instanceA_tag_filter_id, instanceA_blacklist): instanceA_tag_filter_id, instanceA_blacklist, instanceB_contents):
global is_radarr, is_sonarr, is_test_run global is_radarr, is_sonarr, is_test_run, sync_monitor
search_ids = [] search_ids = []
# if given instance A profile id then we want to filter out content without that id # if given instance A profile id then we want to filter out content without that id
@ -203,7 +204,9 @@ def sync_servers(instanceA_contents, instanceB_language_id, instanceB_contentIds
# for each content id in instance A, check if it needs to be synced to instance B # for each content id in instance A, check if it needs to be synced to instance B
for content in instanceA_contents: for content in instanceA_contents:
if content[content_id_key] not in instanceB_contentIds: content_not_synced = content[content_id_key] not in instanceB_contentIds
# only skip alrerady synced items if we arent syncing monitoring as well
if content_not_synced or sync_monitor:
title = content.get('title') or content.get('artistName') title = content.get('title') or content.get('artistName')
instance_path = instanceB_path or dirname(content.get('path')) instance_path = instanceB_path or dirname(content.get('path'))
@ -247,11 +250,10 @@ def sync_servers(instanceA_contents, instanceB_language_id, instanceB_contentIds
logging.debug(f'Skipping content {title} - blacklist ID: {content_id}') logging.debug(f'Skipping content {title} - blacklist ID: {content_id}')
continue continue
logging.info(f'syncing content title "{title}"')
# get the POST payload and sync content to instance B # generate content from instance A to sync into instance B
payload = get_new_content_payload( formatted_content = get_content_details(
content=content, content=dict(content),
instance_path=instance_path, instance_path=instance_path,
instance_profile_id=instanceB_profile_id, instance_profile_id=instanceB_profile_id,
instance_url=instanceB_url, instance_url=instanceB_url,
@ -261,9 +263,10 @@ def sync_servers(instanceA_contents, instanceB_language_id, instanceB_contentIds
if is_test_run: if is_test_run:
logging.info('content title "{0}" synced successfully (test only)'.format(title)) logging.info('content title "{0}" synced successfully (test only)'.format(title))
else: elif content_not_synced:
sync_response = instanceB_session.post(instanceB_content_url, data=json.dumps(payload)) # sync content if not synced
logging.info(f'syncing content title "{title}"')
sync_response = instanceB_session.post(instanceB_content_url, data=json.dumps(formatted_content))
# check response and save content id for searching later on if success # check response and save content id for searching later on if success
if sync_response.status_code != 201 and sync_response.status_code != 200: if sync_response.status_code != 201 and sync_response.status_code != 200:
logger.error(f'server sync error for {title} - response: {sync_response.text}') logger.error(f'server sync error for {title} - response: {sync_response.text}')
@ -274,12 +277,33 @@ def sync_servers(instanceA_contents, instanceB_language_id, instanceB_contentIds
logger.error(f'Could not decode sync response from {instanceB_content_url}') logger.error(f'Could not decode sync response from {instanceB_content_url}')
logging.info('content title "{0}" synced successfully'.format(title)) logging.info('content title "{0}" synced successfully'.format(title))
elif sync_monitor:
# else if is already synced and we want to sync monitoring then sync that now
# find matching content from instance B to check monitored status
matching_content_instanceB = list(filter(lambda content_instanceB: content_instanceB['titleSlug'] == content.get('titleSlug'), instanceB_contents))
if(len(matching_content_instanceB) == 1):
matching_content_instanceB = matching_content_instanceB[0]
# if we found a content match from instance B, then check monitored status - if different then sync from A to B
if matching_content_instanceB['monitored'] != content['monitored']:
matching_content_instanceB['monitored'] = content['monitored']
instanceB_content_url = get_content_put_path(instanceB_url, instanceB_key, matching_content_instanceB.get('id'))
sync_response = instanceB_session.put(instanceB_content_url, data=json.dumps(matching_content_instanceB))
# check response and save content id for searching later on if success
if sync_response.status_code != 202:
logger.error(f'server monitoring sync error for {title} - response: {sync_response.text}')
else:
try:
search_ids.append(int(sync_response.json()['id']))
except:
logger.error(f'Could not decode sync response from {instanceB_content_url}')
logging.info('content title "{0}" monitoring synced successfully'.format(title))
logging.info(f'{len(search_ids)} contents synced successfully') logging.info(f'{len(search_ids)} contents synced successfully')
def get_instance_contents(instance_url, instance_key, instance_session, instance_name=''): def get_instance_contents(instance_url, instance_key, instance_session, instance_name=''):
instance_contentIds = [] instance_contentIds = []
instance_content_url = get_content_path(instance_url, instance_key) instance_content_url = get_content_path(instance_url, instance_key)
instance_contents = instance_session.get(instance_content_url) instance_contents = instance_session.get(instance_content_url)
@ -296,34 +320,25 @@ def get_instance_contents(instance_url, instance_key, instance_session, instance
for content_to_sync in instance_contents: for content_to_sync in instance_contents:
instance_contentIds.append(content_to_sync[content_id_key]) instance_contentIds.append(content_to_sync[content_id_key])
logger.debug('{} contents in instance{}'.format(len(instance_contentIds), instance_name)) logger.debug('{} contents in instance {}'.format(len(instance_contentIds), instance_name))
return instance_contents, instance_contentIds return instance_contents, instance_contentIds
def check_status(instance_session, instance_url, instance_key, instance_name='', changed_api_version=False): def check_status(instance_session, instance_url, instance_key, instance_name=''):
global api_version global api_version
instance_status_url = get_status_path( instance_status_url = get_status_path(instance_url, instance_key)
instance_url, instance_key, changed_api_version)
error_message = f'Could not connect to instance{instance_name}: {instance_status_url}' error_message = f'Could not connect to instance{instance_name}: {instance_status_url}'
status_response = None status_response = None
try: try:
status_response = instance_session.get(instance_status_url) status_response = instance_session.get(instance_status_url)
if status_response.status_code != 200:
# only test again if not lidarr and we haven't tested v3 already
if status_response.status_code != 200 and not changed_api_version and not is_lidarr:
logger.debug(f'check api_version again')
status_response = check_status(instance_session, instance_url, instance_key, instance_name, True)
elif status_response.status_code != 200:
logger.error(error_message) logger.error(error_message)
exit_system() exit_system()
except: except:
if not changed_api_version and not is_lidarr: logger.error(error_message)
logger.debug(f'check api_version again exception') exit_system()
status_response = check_status(
instance_session, instance_url, instance_key, instance_name, True)
if status_response is None: if status_response is None:
logger.error(error_message) logger.error(error_message)
@ -355,12 +370,6 @@ def sync_content():
instanceB_session = requests.Session() instanceB_session = requests.Session()
instanceB_session.trust_env = False instanceB_session.trust_env = False
# check if we tested if we are using v2 or v3
if not tested_api_version:
check_status(instanceA_session, instanceA_url, instanceA_key, instance_name='A')
check_status(instanceB_session, instanceB_url, instanceB_key, instance_name='B')
tested_api_version = True
# if given a profile instead of a profile id then try to find the profile id # if given a profile instead of a profile id then try to find the profile id
if not instanceA_profile_id and instanceA_profile: if not instanceA_profile_id and instanceA_profile:
instanceA_profile_id = get_profile_from_id(instanceA_session, instanceA_url, instanceA_key, instanceA_profile, 'A') instanceA_profile_id = get_profile_from_id(instanceA_session, instanceA_url, instanceA_key, instanceA_profile, 'A')
@ -433,6 +442,7 @@ def sync_content():
logger.info('syncing content from instance A to instance B') logger.info('syncing content from instance A to instance B')
sync_servers( sync_servers(
instanceA_contents=instanceA_contents, instanceA_contents=instanceA_contents,
instanceB_contents=instanceB_contents,
instanceB_contentIds=instanceB_contentIds, instanceB_contentIds=instanceB_contentIds,
instanceB_language_id=instanceB_language_id, instanceB_language_id=instanceB_language_id,
instanceB_path=instanceB_path, instanceB_path=instanceB_path,
@ -452,6 +462,7 @@ def sync_content():
sync_servers( sync_servers(
instanceA_contents=instanceB_contents, instanceA_contents=instanceB_contents,
instanceB_contents=instanceA_contents,
instanceB_contentIds=instanceA_contentIds, instanceB_contentIds=instanceA_contentIds,
instanceB_language_id=instanceA_language_id, instanceB_language_id=instanceA_language_id,
instanceB_path=instanceA_path, instanceB_path=instanceA_path,

Write Preview
Loading…
Cancel
Save