????
Your IP : 52.14.75.147
# Script allows to cleanup target machine's DML DB from foreign archives and backups
#
# Requirements:
# - Installed Acronis Cyber Protection agent
# - Running of the script requires admin rights
#
# Notes:
# By default script
# - Will be running in report mode, to display statistics related to archives and backups that are bounded to a machine
# - Uses agent's DML database, so script will try to stop MMS service first, apply required actions, then start MMS
# override path with --db-path option (or -d), in that case MMS service will not be touched
# - Uses machine ID's from registry, override it with --machine-id option (or -m)
# - Cleanup mode is turned off, override it with --cleanup option (or -c)
# To run script in report mode for current machine
# "C:\Program Files\Acronis\PyShell\python.exe" cleanup_backups.py
# To run script in cleanup mode for current machine
# "C:\Program Files\Acronis\PyShell\python.exe" cleanup_backups.py -c
# To run script in cleanup mode for current machine and for specified location only
# "C:\Program Files\Acronis\PyShell\python.exe" cleanup_backups.py -c -l 8F44EB8E-E15E-4B3E-BBC4-40924F7EE303
# To run script in report mode for a specific machine
# "C:\Program Files\Acronis\PyShell\python.exe" cleanup_backups.py -m D6E857EF-6781-4AB2-97A5-AD20A15D3E27
# To run script in cleanup mode for a specific machine (all foreign archives and backups will be removed except specified machine)
# "C:\Program Files\Acronis\PyShell\python.exe" cleanup_backups.py -c -m D6E857EF-6781-4AB2-97A5-AD20A15D3E27
# To run script in cleanup mode for custom DB path
# "C:\Program Files\Acronis\PyShell\python.exe" cleanup_backups.py -c -d D:\TTASK-50248\var\lib\Acronis\BackupAndRecovery\MMSData\DML\F4CEEE47-042C-4828-95A0-DE44EC267A28.db3
# If everything is good then script should be finished with output "Successfully finished."
import acrort
import argparse
import os
import platform
import re
import subprocess
import sys
import time
OS_WINDOWS = 'Windows'
OS_LINUX = 'Linux'
OS_MAC = 'Darwin'
CHUNK_SIZE = 250
data = {
OS_WINDOWS: {
'product_path': lambda x: get_windows_product_installation_path(),
'start_mms_args': ['sc', 'start', 'mms'],
'stop_mms_args': ['sc', 'stop', 'mms'],
},
OS_LINUX: {
'product_path': '/usr/lib/' + acrort.common.BRAND_NAME,
'start_mms_args': ['service', 'acronis_mms', 'start'],
'stop_mms_args': ['service', 'acronis_mms', 'stop'],
},
OS_MAC: {
'product_path': '/Library/Application Support/BackupClient/' + acrort.common.BRAND_NAME,
'start_mms_args': ['launchctl', 'start', 'acronis_mms'],
'stop_mms_args': ['launchctl', 'stop', 'acronis_mms'],
}
}
def is_guid(key):
RE_UUID = re.compile("[0-F]{8}-[0-F]{4}-[0-F]{4}-[0-F]{4}-[0-F]{12}", re.I)
return bool(RE_UUID.match(key))
def get_settings_key():
return r'SOFTWARE\{}\BackupAndRecovery\Settings'.format(acrort.common.BRAND_NAME)
def get_machine_settings_key():
return get_settings_key() + r'\MachineManager'
def get_current_machine_id():
return registry_read_string(get_machine_settings_key(), 'MMSCurrentMachineID')
def get_windows_product_installation_path():
key = r'SOFTWARE\{}\Installer'.format(acrort.common.BRAND_NAME)
return registry_read_string(key, 'TargetDir')
def get_product_installation_path():
value = data[platform.system()]['product_path']
if isinstance(value, str):
return value
return value(1)
def get_product_data_path():
return os.path.join(acrort.fs.APPDATA_COMMON, acrort.common.BRAND_NAME)
def registry_read_string(key_name, value_name, open_hive=None):
root_reg = acrort.registry.open_system_hive(hive=open_hive)
if key_name not in root_reg.subkeys:
acrort.common.make_logic_error(
"Key '{}' not found. May be MMS service is not installed".format(key_name)).throw()
key = root_reg.subkeys.open(key_name=key_name)
if value_name not in key.values:
acrort.common.make_logic_error(
"Value '{}' not found. May be MMS service is not installed".format(value_name)).throw()
value = key.values.open(value_name=value_name)
return value.get(acrort.registry.TYPE_SZ)
def is_service_running(service_name):
system = platform.system()
if system == OS_WINDOWS:
args = ['sc', 'query', service_name]
ps = subprocess.Popen(args, stdout=subprocess.PIPE)
output = ps.communicate()[0]
return 'STOPPED' not in str(output)
elif system in [OS_MAC, OS_LINUX]:
ps = subprocess.Popen(('ps', 'aux'), stdout=subprocess.PIPE)
output = ps.communicate()[0]
return ('/' + service_name) in str(output)
else:
acrort.common.make_logic_error('Unsupported operating system: ' + system).throw()
def start_service(args, service_name):
try:
print('Executing command: {}'.format(' '.join(args)))
subprocess.run(args, stdout=subprocess.DEVNULL, check=True)
except Exception as e:
print('Can\'t start %s service: %s', service_name, str(e))
def stop_service(args, service_name, is_service_running):
try:
print('Executing command: {}'.format(' '.join(args)))
subprocess.run(args, stdout=subprocess.DEVNULL, check=True, timeout=60)
except subprocess.CalledProcessError as e:
acrort.common.make_logic_error(
'Can\'t stop {} service with error: {}'.format(service_name, str(e))).throw()
else:
# Lookup for target process, wait if it is still here
wait_reattempts = 10
while wait_reattempts:
time.sleep(10)
if not is_service_running():
break
wait_reattempts = wait_reattempts - 1
if not wait_reattempts:
acrort.common.make_logic_error(
'Can\'t stop %s service, please stop it manually.'.format(service_name)).throw()
def is_mms_service_running():
return is_service_running('mms')
def start_mms_service():
start_service(data[platform.system()]['start_mms_args'], 'MMS')
def stop_mms_service():
stop_service(data[platform.system()]['stop_mms_args'], 'MMS', is_mms_service_running)
def get_default_dml_database_path():
return os.path.join(get_product_data_path(), 'BackupAndRecovery', 'MMSData', 'DML', 'F4CEEE47-042C-4828-95A0-DE44EC267A28.db3')
# Archives specs
def make_select_all_archives_spec():
return [
('^Is', 'string', 'DMS::Cache::Archive'),
]
def make_select_archives_spec(archive_ids):
ids = [[('', 'string', id)] for id in archive_ids]
return [
('^Is', 'string', 'DMS::Cache::Archive'),
('.ID', 'string',''),
('.ID^ValueIn', 'complex_trait', [('', 'array', ids)]),
]
def make_select_foreign_archives_spec(machine_id, location_id, limit):
options = [
('.LimitOptions', 'dword', limit),
]
result = [
('^Is', 'string', 'DMS::Cache::Archive'),
('^Not', 'complex_trait', [
('.Attributes.MachineID', 'string', machine_id)
])
]
if location_id:
result += [('.Attributes.LocationID', 'guid', location_id)]
return result, options
def make_select_machine_archives_spec(machine_id, location_id):
result = [
('.Attributes.MachineID', 'string', ''),
('.Attributes.MachineID^Like', 'string', machine_id),
('^Is', 'string', 'DMS::Cache::Archive'),
]
if location_id:
result += [('.Attributes.LocationID', 'guid', location_id)]
return result
# Backups specs
def make_select_all_backups_spec():
return [
('^Is', 'string', 'DMS::Cache::Slice'),
]
def make_select_backups_spec(backup_ids):
ids = [[('', 'string', id)] for id in backup_ids]
return [
('^Is', 'string', 'DMS::Cache::Slice'),
('.ID', 'string',''),
('.ID^ValueIn', 'complex_trait', [('', 'array', ids)]),
]
def make_select_machine_backups_spec(machine_id, location_id):
result = [
('^Is', 'string', 'DMS::Cache::Slice'),
('.Attributes.Location.LocationMachineID', 'string', ''),
('.Attributes.Location.LocationMachineID^Like', 'string', machine_id)
]
if location_id:
result += [('.Attributes.LocationID', 'guid', location_id)]
return result
def make_select_foreign_backups_spec(machine_id, location_id, limit):
options = [
('.LimitOptions', 'dword', limit),
]
result = [
('^Is', 'string', 'DMS::Cache::Slice'),
('^Not', 'complex_trait', [
('.Attributes.Location.LocationMachineID', 'string', machine_id),
])
]
if location_id:
result += [('.Attributes.LocationID', 'guid', location_id)]
return result, options
# Zmq acks specs
def make_select_channel_zmqgw_acks_spec(channel):
return [
('^Is', 'string', 'ZmqGw::Ack'),
('.ID.Channel', 'string', channel),
]
def make_select_zmq_acks_spec_for_deletion(zmq_acks):
ids = [[('', 'string', id)] for id in zmq_acks]
return [
('^Is', 'string', 'ZmqGw::Ack'),
('.ID.Key', 'string',''),
('.ID.Key^ValueIn', 'complex_trait', [('', 'array', ids)]),
]
def make_select_zmq_acks_spec(channel, limit):
options = [
('.LimitOptions', 'dword', limit),
]
return [
('^Is', 'string', 'ZmqGw::Ack'),
('.ID.Channel', 'string', channel),
], options
def get_objects(dml, pattern, options=None):
if options:
return dml.select(acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern),
acrort.plain.Unit(flat=options)))
return dml.select(acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern)))
def get_objects_count(dml, pattern):
options = [
('.Counter.CounterObjectTemplate.ID', 'string', 'Count'),
('.Counter.CounterObjectTemplate.ID^PrimaryKey', 'nil', None)
]
return dml.select1(acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern), acrort.plain.Unit(flat=options))).CounterValue.ref
def print_progress(current, max):
sys.stdout.write('{} of {}\r'.format(current, max))
def get_archives_count(dml, machine_id, location_id):
all_archives = get_objects_count(dml, make_select_all_archives_spec())
machine_archives = get_objects_count(dml, make_select_machine_archives_spec(machine_id, location_id))
zmq_acks = get_objects_count(dml, make_select_channel_zmqgw_acks_spec('Archive'))
return all_archives, machine_archives, all_archives - machine_archives, zmq_acks
def cleanup_archives(dml, machine_id, location_id, all_archives_count):
counter = 0
foreign_archives = ['dummy']
while foreign_archives:
print_progress(counter, all_archives_count)
foreign_archives = get_objects(dml, *make_select_foreign_archives_spec(machine_id, location_id, CHUNK_SIZE))
if foreign_archives:
ids = [item.ID.ref for item in foreign_archives]
dml.delete(pattern=acrort.plain.Unit(flat=make_select_archives_spec(ids)))
counter += len(foreign_archives)
print_progress(counter, all_archives_count)
def get_backups_count(dml, machine_id, location_id):
all_backups = get_objects_count(dml, make_select_all_backups_spec())
machine_backups = get_objects_count(dml, make_select_machine_backups_spec(machine_id, location_id))
zmq_acks = get_objects_count(dml, make_select_channel_zmqgw_acks_spec('Slice'))
return all_backups, machine_backups, all_backups - machine_backups, zmq_acks
def cleanup_backups(dml, machine_id, location_id, all_backups_count):
counter = 0
foreign_backups = ['dummy']
print_progress(counter, all_backups_count)
while foreign_backups:
foreign_backups = get_objects(dml, *make_select_foreign_backups_spec(machine_id, location_id, CHUNK_SIZE))
if foreign_backups:
ids = [item.ID.ref for item in foreign_backups]
dml.delete(pattern=acrort.plain.Unit(flat=make_select_backups_spec(ids)))
counter += len(foreign_backups)
print_progress(counter, all_backups_count)
def cleanup_zmqgw_acks(dml, all_acks_count):
counter = 0
print_progress(counter, all_acks_count)
for channel in ['Archive', 'Slice']:
acks = ['dummy']
while acks:
acks = get_objects(dml, *make_select_zmq_acks_spec(channel, CHUNK_SIZE))
if acks:
ids = [item.ID.Key.ref for item in acks]
dml.delete(pattern=acrort.plain.Unit(flat=make_select_zmq_acks_spec_for_deletion(ids)))
counter += len(acks)
print_progress(counter, all_acks_count)
def main():
system = platform.system()
if system not in [OS_WINDOWS, OS_LINUX, OS_MAC]:
acrort.common.make_logic_error('Unsupported operating system: ' + system).throw()
parser = argparse.ArgumentParser(description='Cleanup DML DB from foreign archives and backups')
parser.add_argument(
'-c', '--cleanup', required=False, action="store_true",
help='Flag whether to cleanup DML DB from foreign archives and backups')
parser.add_argument(
'-d', '--db-path', required=False, nargs=1,
help='Full path where DML database is placed, product path will be used if it is not specified')
parser.add_argument(
'-m', '--machine-id', required=False, nargs=1,
help='Machine identifier in form <GUID>, will be used from the current MMS installation if it is not specified')
parser.add_argument(
'-b', '--backups', required=False, action="store_true",
help='Flag whether to report number of foreign archives and backups only')
parser.add_argument(
'-a', '--acks', required=False, action="store_true",
help='Flag whether to report number of ZMQ acks only')
parser.add_argument(
'-l', '--location-id', required=False, nargs=1,
help='Location identifier in form <GUID>, will be used as additional filter for archive and backups deletion')
args = parser.parse_args()
db_path = get_default_dml_database_path()
if args.db_path:
db_path = args.db_path[0]
silent_mode = args.backups or args.acks
if not silent_mode:
print("DML database used at: {}".format(db_path))
machine_id = None
if args.machine_id:
machine_id = args.machine_id[0]
if not machine_id:
machine_id = get_current_machine_id()
if not silent_mode:
print("Machine to preserve archives and backups from: {}".format(machine_id))
machine_id = machine_id.upper()
if not is_guid(machine_id):
print("Machine identifier error: invalid GUID format: {}".format(machine_id))
return
location_id = None
if args.location_id:
location_id = args.location_id[0]
cleanup = args.cleanup
if cleanup and not args.db_path and is_mms_service_running():
print("Stopping MMS service...")
stop_mms_service()
print("Done.\n")
connection_string = 'sqlite-v2://{}#limit_statement_cache'.format(db_path)
conn = acrort.dml.open_database(connection_string)
archives_count, machine_archives, foreign_archives, zmq_arc_acks = get_archives_count(conn.dml, machine_id, location_id)
backups_count, machine_backups, foreign_backups, zmq_bckp_acks = get_backups_count(conn.dml, machine_id, location_id)
if args.backups:
print(foreign_archives + foreign_backups)
return
elif args.acks:
print(zmq_arc_acks + zmq_bckp_acks)
return
print("Statistics (before cleanup):")
print("Total archives: {}, machine archives: {}, foreign archives: {}, zmq acks: {}".format(archives_count, machine_archives, foreign_archives, zmq_arc_acks))
print("Total backups: {}, machine backups: {}, foreign backups: {}, zmq acks: {}".format(backups_count, machine_backups, foreign_backups, zmq_bckp_acks))
if cleanup:
if foreign_archives:
print("\nCleanup foreign archives...")
cleanup_archives(conn.dml, machine_id, location_id, archives_count)
print("\nDone.\n")
if foreign_backups:
print("\nCleanup foreign backups...")
cleanup_backups(conn.dml, machine_id, location_id, backups_count)
print("\nDone.\n")
if zmq_arc_acks + zmq_bckp_acks:
print("\nCleanup zmq acks...")
cleanup_zmqgw_acks(conn.dml, zmq_arc_acks + zmq_bckp_acks)
print("\nDone.\n")
print("Statistics (after cleanup):")
archives_count, machine_archives, foreign_archives, zmq_arc_acks = get_archives_count(conn.dml, machine_id, location_id)
backups_count, machine_backups, foreign_backups, zmq_bckp_acks = get_backups_count(conn.dml, machine_id, location_id)
print("Total archives: {}, machine archives: {}, foreign archives: {}, zmq acks: {}".format(archives_count, machine_archives, foreign_archives, zmq_arc_acks))
print("Total backups: {}, machine backups: {}, foreign backups: {}, zmq acks: {}".format(backups_count, machine_backups, foreign_backups, zmq_bckp_acks))
if cleanup and not args.db_path:
print("\nStarting MMS service...")
start_mms_service()
print("Done.")
print("\nSuccessfully finished.")
if __name__ == '__main__':
import acrobind
exit(acrobind.interruptable_safe_execute(main))