def backup_restore_do(backup_dir, restore_info, host_collection = None, print_callback = print_stdout, error_callback = print_stderr): #### Private functions begin def restore_vm_file (backup_dir, file_path): backup_file_path = file_path.replace (qubes_base_dir, backup_dir) #print "cp -rp {0} {1}".format (backup_file_path, file_path) # We prefer to use Linux's cp, because it nicely handles sparse files retcode = subprocess.call (["cp", "-p", backup_file_path, file_path]) if retcode != 0: raise QubesException("*** Error while copying file {0} to {1}".format(backup_file_path, file_path)) def restore_vm_dir (backup_dir, src_dir, dst_dir): backup_src_dir = src_dir.replace (qubes_base_dir, backup_dir) # We prefer to use Linux's cp, because it nicely handles sparse files retcode = subprocess.call (["cp", "-rp", backup_src_dir, dst_dir]) if retcode != 0: raise QubesException("*** Error while copying file {0} to {1}".format(backup_src_dir, dest_dir)) #### Private functions end lock_obtained = False if host_collection is None: host_collection = QubesVmCollection() host_collection.lock_db_for_writing() host_collection.load() lock_obtained = True # Add templates... for vm_info in restore_info.values(): if not vm_info['good-to-go']: continue if 'vm' not in vm_info: continue vm = vm_info['vm'] if not vm.is_template(): continue print_callback("-> Restoring Template VM {0}...".format(vm.name)) retcode = subprocess.call (["mkdir", "-p", vm.dir_path]) if retcode != 0: error_callback("*** Cannot create directory: {0}?!".format(dest_dir)) error_callback("Skiping...") continue new_vm = None try: restore_vm_dir (backup_dir, vm.dir_path, qubes_templates_dir); new_vm = host_collection.add_new_templatevm(vm.name, conf_file=vm.conf_file, dir_path=vm.dir_path, installed_by_rpm=False) new_vm.verify_files() except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Skiping VM: {0}".vm.name) if new_vm: host_collection.pop(new_vm.qid) continue try: new_vm.clone_attrs(vm) except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Some VM property will not be restored") try: new_vm.create_appmenus(verbose=True) except Exception as err: error_callback("ERROR during appmenu restore: {0}".format(err)) error_callback("*** VM '{0}' will not have appmenus".format(vm.name)) # ... then NetVMs... for vm_info in restore_info.values(): if not vm_info['good-to-go']: continue if 'vm' not in vm_info: continue vm = vm_info['vm'] if not vm.is_netvm(): continue print_callback("-> Restoring {0} {1}...".format(vm.type, vm.name)) retcode = subprocess.call (["mkdir", "-p", vm.dir_path]) if retcode != 0: error_callback("*** Cannot create directory: {0}?!".format(dest_dir)) error_callback("Skiping...") continue template = None if vm.template is not None: template_name = vm_info['template'] template = host_collection.get_vm_by_name(template_name) new_vm = None try: restore_vm_dir (backup_dir, vm.dir_path, qubes_servicevms_dir); if vm.type == "NetVM": new_vm = host_collection.add_new_netvm(vm.name, template, conf_file=vm.conf_file, dir_path=vm.dir_path, label=vm.label) elif vm.type == "ProxyVM": new_vm = host_collection.add_new_proxyvm(vm.name, template, conf_file=vm.conf_file, dir_path=vm.dir_path, label=vm.label) except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Skiping VM: {0}".format(vm.name)) if new_vm: host_collection.pop(new_vm.qid) continue try: new_vm.clone_attrs(vm) except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Some VM property will not be restored") try: new_vm.verify_files() except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Skiping VM: {0}".format(vm.name)) host_collection.pop(new_vm.qid) continue # ... then appvms... for vm_info in restore_info.values(): if not vm_info['good-to-go']: continue if 'vm' not in vm_info: continue vm = vm_info['vm'] if not vm.is_appvm(): continue print_callback("-> Restoring AppVM {0}...".format(vm.name)) retcode = subprocess.call (["mkdir", "-p", vm.dir_path]) if retcode != 0: error_callback("*** Cannot create directory: {0}?!".format(dest_dir)) error_callback("Skiping...") continue template = None if vm.template is not None: template_name = vm_info['template'] template = host_collection.get_vm_by_name(template_name) new_vm = None try: restore_vm_dir (backup_dir, vm.dir_path, qubes_appvms_dir); new_vm = host_collection.add_new_appvm(vm.name, template, conf_file=vm.conf_file, dir_path=vm.dir_path, label=vm.label) except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Skiping VM: {0}".format(vm.name)) if new_vm: host_collection.pop(new_vm.qid) continue try: new_vm.clone_attrs(vm) except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Some VM property will not be restored") try: new_vm.create_appmenus(verbose=True) except Exception as err: error_callback("ERROR during appmenu restore: {0}".format(err)) error_callback("*** VM '{0}' will not have appmenus".format(vm.name)) try: new_vm.verify_files() except Exception as err: error_callback("ERROR: {0}".format(err)) error_callback("*** Skiping VM: {0}".format(vm.name)) host_collection.pop(new_vm.qid) continue # Set network dependencies - only non-default netvm setting for vm_info in restore_info.values(): if not vm_info['good-to-go']: continue if 'vm' not in vm_info: continue vm = vm_info['vm'] host_vm = host_collection.get_vm_by_name(vm.name) if host_vm is None: # Failed/skipped VM continue if not vm.uses_default_netvm: host_vm.netvm = host_collection.get_vm_by_name (vm_info['netvm']) if vm_info['netvm'] is not None else None host_collection.save() if lock_obtained: host_collection.unlock_db() # ... and dom0 home as last step if 'dom0' in restore_info.keys() and restore_info['dom0']['good-to-go']: backup_info = restore_info['dom0'] local_user = grp.getgrnam('qubes').gr_mem[0] home_dir = pwd.getpwnam(local_user).pw_dir backup_dom0_home_dir = backup_dir + '/dom0-home/' + backup_info['username'] restore_home_backupdir = "home-pre-restore-{0}".format (time.strftime("%Y-%m-%d-%H%M%S")) print_callback("-> Restoring home of user '{0}'...".format(local_user)) print_callback("--> Existing files/dirs backed up in '{0}' dir".format(restore_home_backupdir)) os.mkdir(home_dir + '/' + restore_home_backupdir) for f in os.listdir(backup_dom0_home_dir): home_file = home_dir + '/' + f if os.path.exists(home_file): os.rename(home_file, home_dir + '/' + restore_home_backupdir + '/' + f) retcode = subprocess.call (["cp", "-nrp", backup_dom0_home_dir + '/' + f, home_file]) if retcode != 0: error_callback("*** Error while copying file {0} to {1}".format(backup_dom0_home_dir + '/' + f, home_file))
def backup_restore_prepare(backup_dir, options = {}, host_collection = None): # Defaults backup_restore_set_defaults(options) #### Private functions begin def is_vm_included_in_backup (backup_dir, vm): if vm.qid == 0: # Dom0 is not included, obviously return False backup_vm_dir_path = vm.dir_path.replace (qubes_base_dir, backup_dir) if os.path.exists (backup_vm_dir_path): return True else: return False def find_template_name(template, replaces): rx_replace = re.compile("(.*):(.*)") for r in replaces: m = rx_replace.match(r) if m.group(1) == template: return m.group(2) return template #### Private functions end if not os.path.exists (backup_dir): raise QubesException("The backup directory doesn't exist!") backup_collection = QubesVmCollection(store_filename = backup_dir + "/qubes.xml") backup_collection.lock_db_for_reading() backup_collection.load() if host_collection is None: host_collection = QubesVmCollection() host_collection.lock_db_for_reading() host_collection.load() host_collection.unlock_db() backup_vms_list = [vm for vm in backup_collection.values()] host_vms_list = [vm for vm in host_collection.values()] vms_to_restore = {} there_are_conflicting_vms = False there_are_missing_templates = False there_are_missing_netvms = False dom0_username_mismatch = False restore_home = False # ... and the actual data for vm in backup_vms_list: if is_vm_included_in_backup (backup_dir, vm): vms_to_restore[vm.name] = {} vms_to_restore[vm.name]['vm'] = vm; if 'exclude' in options.keys(): vms_to_restore[vm.name]['excluded'] = vm.name in options['exclude'] vms_to_restore[vm.name]['good-to-go'] = False if host_collection.get_vm_by_name (vm.name) is not None: vms_to_restore[vm.name]['already-exists'] = True vms_to_restore[vm.name]['good-to-go'] = False if vm.template is None: vms_to_restore[vm.name]['template'] = None else: templatevm_name = find_template_name(vm.template.name, options['replace-template']) vms_to_restore[vm.name]['template'] = templatevm_name template_vm_on_host = host_collection.get_vm_by_name (templatevm_name) # No template on the host? if not ((template_vm_on_host is not None) and template_vm_on_host.is_template()): # Maybe the (custom) template is in the backup? template_vm_on_backup = backup_collection.get_vm_by_name (templatevm_name) if template_vm_on_backup is None or not \ (is_vm_included_in_backup(backup_dir, template_vm_on_backup) and \ template_vm_on_backup.is_template()): if options['use-default-template']: vms_to_restore[vm.name]['orig-template'] = templatevm_name vms_to_restore[vm.name]['template'] = host_collection.get_default_template().name else: vms_to_restore[vm.name]['missing-template'] = True vms_to_restore[vm.name]['good-to-go'] = False if vm.netvm is None: vms_to_restore[vm.name]['netvm'] = None else: netvm_name = vm.netvm.name vms_to_restore[vm.name]['netvm'] = netvm_name # Set to None to not confuse QubesVm object from backup # collection with host collection (further in clone_attrs). Set # directly _netvm to suppress setter action, especially # modifying firewall vm._netvm = None netvm_on_host = host_collection.get_vm_by_name (netvm_name) # No netvm on the host? if not ((netvm_on_host is not None) and netvm_on_host.is_netvm()): # Maybe the (custom) netvm is in the backup? netvm_on_backup = backup_collection.get_vm_by_name (netvm_name) if not ((netvm_on_backup is not None) and netvm_on_backup.is_netvm() and is_vm_included_in_backup(backup_dir, netvm_on_backup)): if options['use-default-netvm']: vms_to_restore[vm.name]['netvm'] = host_collection.get_default_netvm().name vm.uses_default_netvm = True elif options['use-none-netvm']: vms_to_restore[vm.name]['netvm'] = None else: vms_to_restore[vm.name]['missing-netvm'] = True vms_to_restore[vm.name]['good-to-go'] = False if 'good-to-go' not in vms_to_restore[vm.name].keys(): vms_to_restore[vm.name]['good-to-go'] = True # ...and dom0 home if options['dom0-home'] and os.path.exists(backup_dir + '/dom0-home'): vms_to_restore['dom0'] = {} local_user = grp.getgrnam('qubes').gr_mem[0] dom0_homes = os.listdir(backup_dir + '/dom0-home') if len(dom0_homes) > 1: raise QubesException("More than one dom0 homedir in backup") vms_to_restore['dom0']['username'] = dom0_homes[0] if dom0_homes[0] != local_user: vms_to_restore['dom0']['username-mismatch'] = True if not options['ignore-dom0-username-mismatch']: vms_to_restore['dom0']['good-to-go'] = False if 'good-to-go' not in vms_to_restore['dom0']: vms_to_restore['dom0']['good-to-go'] = True return vms_to_restore