def get_sorted_wifis(profile):
"""Get SSIDs from OS and merge with settings in DB."""
from vorta.models import WifiSettingModel
if sys.platform == 'darwin':
plist_path = '/Library/Preferences/SystemConfiguration/com.apple.airport.preferences.plist'
plist_file = open(plist_path, 'rb')
wifis = plistlib.load(plist_file).get('KnownNetworks')
if wifis is not None:
for wifi in wifis.values():
timestamp = wifi.get('LastConnected', None)
ssid = wifi['SSIDString']
db_wifi, created = WifiSettingModel.get_or_create(
ssid=ssid,
profile=profile.id,
defaults={
'last_connected': timestamp,
'allowed': True
})
# update last connected time
if not created and db_wifi.last_connected != timestamp:
db_wifi.last_connected = timestamp
db_wifi.save()
# remove Wifis that were deleted in the system.
deleted_wifis = WifiSettingModel.select() \
.where(WifiSettingModel.ssid.not_in([w['SSIDString'] for w in wifis.values()]))
for wifi in deleted_wifis:
wifi.delete_instance()
return WifiSettingModel.select() \
.where(WifiSettingModel.profile == profile.id).order_by(-WifiSettingModel.last_connected)
def get_sorted_wifis(profile):
"""
Get Wifi networks known to the OS (only current one on macOS) and
merge with networks from other profiles. Update last connected time.
"""
from vorta.models import WifiSettingModel
# Pull networks known to OS and all other backup profiles
system_wifis = get_network_status_monitor().get_known_wifis()
from_other_profiles = WifiSettingModel.select() \
.where(WifiSettingModel.profile != profile.id).execute()
for wifi in list(from_other_profiles) + system_wifis:
db_wifi, created = WifiSettingModel.get_or_create(
ssid=wifi.ssid,
profile=profile.id,
defaults={
'last_connected': wifi.last_connected,
'allowed': True
})
# Update last connected time
if not created and db_wifi.last_connected != wifi.last_connected:
db_wifi.last_connected = wifi.last_connected
db_wifi.save()
# Finally return list of networks and settings for that profile
return WifiSettingModel.select() \
.where(WifiSettingModel.profile == profile.id).order_by(-WifiSettingModel.last_connected)
def get_sorted_wifis(profile):
"""Get SSIDs from OS and merge with settings in DB."""
from vorta.models import WifiSettingModel
system_wifis = get_network_status_monitor().get_known_wifis()
if system_wifis is None:
# Don't show any networks if we can't get the current list
return []
for wifi in system_wifis:
db_wifi, created = WifiSettingModel.get_or_create(
ssid=wifi.ssid,
profile=profile.id,
defaults={
'last_connected': wifi.last_connected,
'allowed': True
})
# update last connected time
if not created and db_wifi.last_connected != wifi.last_connected:
db_wifi.last_connected = wifi.last_connected
db_wifi.save()
# remove Wifis that were deleted in the system.
deleted_wifis = WifiSettingModel.select() \
.where(WifiSettingModel.ssid.not_in([wifi.ssid for wifi in system_wifis]))
for wifi in deleted_wifis:
wifi.delete_instance()
return WifiSettingModel.select() \
.where(WifiSettingModel.profile == profile.id).order_by(-WifiSettingModel.last_connected)
def from_db(cls, profile, store_password=True, include_settings=True):
profile_dict = model_to_dict(profile, exclude=[RepoModel.id]) # Have to retain profile ID
keyring = VortaKeyring.get_keyring()
if store_password:
profile_dict['password'] = keyring.get_password('vorta-repo', profile.repo.url)
# For all below, exclude ids to prevent collisions. DB will automatically reassign ids
# Add SourceFileModel
profile_dict['SourceFileModel'] = [
model_to_dict(
source,
recurse=False, exclude=[SourceFileModel.id]) for source in SourceFileModel.select().where(
SourceFileModel.profile == profile)]
# Add SchemaVersion
profile_dict['SchemaVersion'] = model_to_dict(SchemaVersion.get(id=1))
if include_settings:
# Add WifiSettingModel
profile_dict['WifiSettingModel'] = [
model_to_dict(
wifi, recurse=False) for wifi in WifiSettingModel.select().where(
WifiSettingModel.profile == profile.id)]
# Add SettingsModel
profile_dict['SettingsModel'] = [
model_to_dict(s, exclude=[SettingsModel.id]) for s in SettingsModel]
return ProfileExport(profile_dict)
def save_wifi_item(self, item):
db_item = WifiSettingModel.get(ssid=item.text(),
profile=self.profile().id)
db_item.allowed = item.checkState() == 2
db_item.save()
def to_db(self, overwrite_profile=False, overwrite_settings=True):
profile_schema = self._profile_dict['SchemaVersion']['version']
keyring = VortaKeyring.get_keyring()
if SCHEMA_VERSION < profile_schema:
raise VersionException()
elif SCHEMA_VERSION > profile_schema:
# Add model upgrading code here, only needed if not adding columns
if profile_schema < 16:
for sourcedir in self._profile_dict['SourceFileModel']:
sourcedir['dir_files_count'] = -1
sourcedir['dir_size'] = -1
sourcedir['path_isdir'] = False
existing_profile = None
if overwrite_profile:
existing_profile = BackupProfileModel.get_or_none(BackupProfileModel.name == self.name)
if existing_profile:
self._profile_dict['id'] = existing_profile.id
if not overwrite_profile or not existing_profile:
# Guarantee uniqueness of ids
while BackupProfileModel.get_or_none(BackupProfileModel.id == self.id) is not None:
self._profile_dict['id'] += 1
# Add suffix incase names are the same
if BackupProfileModel.get_or_none(BackupProfileModel.name == self.name) is not None:
suffix = 1
while BackupProfileModel.get_or_none(BackupProfileModel.name == f"{self.name}-{suffix}") is not None:
suffix += 1
self._profile_dict['name'] = f"{self.name}-{suffix}"
# Load existing repo or restore it
if self._profile_dict['repo']:
repo = RepoModel.get_or_none(RepoModel.url == self.repo_url)
if repo is None:
# Load repo from export
repo = dict_to_model(RepoModel, self._profile_dict['repo'])
repo.save(force_insert=True)
self._profile_dict['repo'] = model_to_dict(repo)
if self.repo_password:
keyring.set_password('vorta-repo', self.repo_url, self.repo_password)
del self._profile_dict['password']
# Delete and recreate the tables to clear them
if overwrite_settings:
db.drop_tables([SettingsModel, WifiSettingModel])
db.create_tables([SettingsModel, WifiSettingModel])
SettingsModel.insert_many(self._profile_dict['SettingsModel']).execute()
WifiSettingModel.insert_many(self._profile_dict['WifiSettingModel']).execute()
# Set the profile ids to be match new profile
for source in self._profile_dict['SourceFileModel']:
source['profile'] = self.id
SourceFileModel.insert_many(self._profile_dict['SourceFileModel']).execute()
# Delete added dictionaries to make it match BackupProfileModel
del self._profile_dict['SettingsModel']
del self._profile_dict['SourceFileModel']
del self._profile_dict['WifiSettingModel']
del self._profile_dict['SchemaVersion']
# dict to profile
new_profile = dict_to_model(BackupProfileModel, self._profile_dict)
if overwrite_profile and existing_profile:
force_insert = False
else:
force_insert = True
new_profile.save(force_insert=force_insert)
init_db() # rerun db init code to perform the same operations on the new as as on application boot
return new_profile
def prepare(cls, profile):
"""
`borg create` is called from different places and needs some preparation.
Centralize it here and return the required arguments to the caller.
"""
ret = super().prepare(profile)
if not ret['ok']:
return ret
else:
ret['ok'] = False # Set back to False, so we can do our own checks here.
n_backup_folders = SourceFileModel.select().count()
if n_backup_folders == 0:
ret['message'] = trans_late('messages',
'Add some folders to back up first.')
return ret
network_status_monitor = get_network_status_monitor()
current_wifi = network_status_monitor.get_current_wifi()
if current_wifi is not None:
wifi_is_disallowed = WifiSettingModel.select().where(
(WifiSettingModel.ssid == current_wifi) & (
WifiSettingModel.allowed == False # noqa
) & (WifiSettingModel.profile == profile))
if wifi_is_disallowed.count() > 0 and profile.repo.is_remote_repo(
):
ret['message'] = trans_late('messages',
'Current Wifi is not allowed.')
return ret
if profile.repo.is_remote_repo() and profile.dont_run_on_metered_networks \
and network_status_monitor.is_network_metered():
ret['message'] = trans_late(
'messages', 'Not running backup over metered connection.')
return ret
ret['profile'] = profile
ret['repo'] = profile.repo
# Run user-supplied pre-backup command
if cls.pre_post_backup_cmd(ret) != 0:
ret['message'] = trans_late(
'messages', 'Pre-backup command returned non-zero exit code.')
return ret
if not profile.repo.is_remote_repo() and not os.path.exists(
profile.repo.url):
ret['message'] = trans_late('messages',
'Repo folder not mounted or moved.')
return ret
if 'zstd' in profile.compression and not borg_compat.check('ZSTD'):
ret['message'] = trans_late(
'messages',
'Your current Borg version does not support ZStd compression.')
return ret
cmd = [
'borg',
'create',
'--list',
'--progress',
'--info',
'--log-json',
'--json',
'--filter=AM',
'-C',
profile.compression,
]
# Add excludes
# Partly inspired by borgmatic/borgmatic/borg/create.py
if profile.exclude_patterns is not None:
exclude_dirs = []
for p in profile.exclude_patterns.split('\n'):
if p.strip():
expanded_directory = os.path.expanduser(p.strip())
exclude_dirs.append(expanded_directory)
if exclude_dirs:
pattern_file = tempfile.NamedTemporaryFile('w', delete=False)
pattern_file.write('\n'.join(exclude_dirs))
pattern_file.flush()
cmd.extend(['--exclude-from', pattern_file.name])
if profile.exclude_if_present is not None:
for f in profile.exclude_if_present.split('\n'):
if f.strip():
cmd.extend(['--exclude-if-present', f.strip()])
# Add repo url and source dirs.
new_archive_name = format_archive_name(profile,
profile.new_archive_name)
cmd.append(f"{profile.repo.url}::{new_archive_name}")
for f in SourceFileModel.select().where(
SourceFileModel.profile == profile.id):
cmd.append(f.dir)
ret['message'] = trans_late('messages', 'Starting backup...')
ret['ok'] = True
ret['cmd'] = cmd
return ret