def single_files(filename): '''check/update a single file''' '''returns (True, path_in_synctree) if file is different''' if not filename: stderr('missing filename') return (False, None) (obj, err) = synctool_overlay.find_terse(synctool_overlay.OV_OVERLAY, filename) if err == synctool_overlay.OV_FOUND_MULTIPLE: # multiple source possible # possibilities have already been printed sys.exit(1) if err == synctool_overlay.OV_NOT_FOUND: stderr('%s is not in the overlay tree' % filename) return (False, None) verbose('checking against %s' % obj.print_src()) changed = obj.compare_files() if not changed: stdout('%s is up to date' % filename) terse(synctool_lib.TERSE_OK, filename) unix_out('# %s is up to date\n' % obj.print_dest()) return (changed, obj.src_path)
def master_ping(rank, nodes): nodename = NODESET.get_nodename_from_interface(nodes[rank]) if nodename == synctool_param.NODENAME: print '%s: up' % nodename return verbose('pinging %s' % nodename) unix_out('%s %s' % (synctool_param.PING_CMD, nodes[rank]))
def master_pkg(rank, args): # the master node only displays what we're running (nodes, ssh_cmd_arr, pkg_cmd_arr) = args node = nodes[rank] nodename = NODESET.get_nodename_from_interface(node) verbose('running synctool-pkg on node %s' % nodename) unix_out('%s %s %s' % (string.join(ssh_cmd_arr), node, string.join(pkg_cmd_arr)))
def hard_delete_file(self): file = self.dest_path unix_out('rm -f %s' % file) if not synctool_lib.DRY_RUN: verbose(' os.unlink(%s)' % file) try: os.unlink(file) except OSError, reason: stderr('failed to delete %s : %s' % (file, reason))
def set_permissions(self): file = self.dest_path mode = self.src_statbuf.mode unix_out('chmod 0%o %s' % (mode & 07777, file)) if not synctool_lib.DRY_RUN: verbose(' os.chmod(%s, %04o)' % (file, mode & 07777)) try: os.chmod(file, mode & 07777) except OSError, reason: stderr('failed to chmod %04o %s : %s' % (mode & 07777, file, reason))
def set_owner(self): file = self.dest_path uid = self.src_statbuf.uid gid = self.src_statbuf.gid unix_out("chown %s.%s %s" % (self.src_ascii_uid(), self.src_ascii_gid(), file)) if not synctool_lib.DRY_RUN: verbose(" os.chown(%s, %d, %d)" % (file, uid, gid)) try: os.chown(file, uid, gid) except OSError, reason: stderr("failed to chown %s.%s %s : %s" % (self.src_ascii_uid(), self.src_ascii_gid(), file, reason))
def master_synctool(rank, args): # the master node only displays what we're running (nodes, rsync_cmd_arr, ssh_cmd_arr, synctool_cmd_arr) = args node = nodes[rank] nodename = NODESET.get_nodename_from_interface(node) if rsync_cmd_arr != None: verbose('running rsync $masterdir/ to node %s' % nodename) unix_out('%s %s:%s/' % (string.join(rsync_cmd_arr), node, synctool_param.MASTERDIR)) verbose('running synctool on node %s' % nodename) unix_out('%s %s %s' % (string.join(ssh_cmd_arr), node, string.join(synctool_cmd_arr)))
def mkdir_basepath(self): '''call mkdir -p if the destination directory does not exist yet''' if synctool_lib.DRY_RUN: return # check if the directory exists basedir = os.path.dirname(self.dest_path) stat = synctool_stat.SyncStat(basedir) if not stat.exists(): # create the directory verbose('making directory %s' % synctool_lib.prettypath(basedir)) unix_out('mkdir -p %s' % basedir) synctool_lib.mkdir_p(basedir)
def save_dir(self): if not synctool_param.BACKUP_COPIES: return path = self.dest_path unix_out('mv %s %s.saved' % (path, path)) if not synctool_lib.DRY_RUN: verbose('moving %s to %s.saved' % (path, path)) try: os.rename(path, '%s.saved' % path) except OSError, reason: stderr('failed to move directory to %s.saved : %s' % (path, reason))
def master_ssh(rank, args): (nodes, ssh_cmd_arr, remote_cmd_arr) = args node = nodes[rank] cmd_str = string.join(remote_cmd_arr) if node == synctool_param.NODENAME: verbose('running %s' % cmd_str) unix_out(cmd_str) else: verbose('running %s to %s %s' % (os.path.basename(ssh_cmd_arr[0]), NODESET.get_nodename_from_interface(node), cmd_str)) unix_out('%s %s %s' % (string.join(ssh_cmd_arr), node, cmd_str))
def make_dir(self): self.mkdir_basepath() path = self.dest_path unix_out('umask 077') unix_out('mkdir %s' % path) if not synctool_lib.DRY_RUN: old_umask = os.umask(077) verbose(' os.mkdir(%s)' % path) try: os.mkdir(path) except OSError, reason: stderr('failed to make directory %s : %s' % (path, reason)) os.umask(old_umask)
def erase_saved(self): dest = self.dest_path stat_saved_path = synctool_stat.SyncStat('%s.saved' % dest) if synctool_lib.ERASE_SAVED and stat_saved_path.exists() and not stat_saved_path.isDir(): terse(synctool_lib.TERSE_DELETE, '%s.saved' % dest) unix_out('rm %s.saved' % dest) if synctool_lib.DRY_RUN: stdout(dryrun_msg('erase %s.saved' % dest, 'erase')) else: stdout('erase %s.saved' % dest) verbose(' os.unlink(%s.saved)' % dest) try: os.unlink('%s.saved' % dest) except OSError, reason: stderr('failed to delete %s : %s' % (dest, reason))
def delete_file(self): file = self.dest_path if not synctool_lib.DRY_RUN: if synctool_param.BACKUP_COPIES: unix_out('mv %s %s.saved' % (file, file)) verbose('moving %s to %s.saved' % (file, file)) try: os.rename(file, '%s.saved' % file) except OSError, reason: stderr('failed to move file to %s.saved : %s' % (file, reason)) else: unix_out('rm %s' % file) verbose(' os.unlink(%s)' % file) try: os.unlink(file) except OSError, reason: stderr('failed to delete %s : %s' % (file, reason))
def copy_file(self): self.mkdir_basepath() src = self.src_path dest = self.dest_path if self.dest_isFile(): unix_out('cp %s %s.saved' % (dest, dest)) unix_out('umask 077') unix_out('cp %s %s' % (src, dest)) if not synctool_lib.DRY_RUN: old_umask = os.umask(077) if synctool_param.BACKUP_COPIES: if self.dest_isFile(): verbose(' saving %s as %s.saved' % (dest, dest)) try: shutil.copy2(dest, '%s.saved' % dest) except: stderr('failed to save %s as %s.saved' % (dest, dest)) verbose(' cp %s %s' % (src, dest)) try: shutil.copy2(src, dest) # copy file and stats except: stderr('failed to copy %s to %s' % (self.print_src(), dest)) os.umask(old_umask) else: if self.dest_isFile() and synctool_param.BACKUP_COPIES: verbose(' saving %s as %s.saved' % (dest, dest)) verbose(dryrun_msg(' cp %s %s' % (src, dest)))
def single_task(filename): '''run a single task''' if not filename: stderr('missing task filename') return task_script = filename if task_script[0] != '/': # trick to make find() work for tasks, too task_script = '/' + task_script (obj, err) = synctool_overlay.find_terse(synctool_overlay.OV_TASKS, task_script) if err == synctool_overlay.OV_FOUND_MULTIPLE: # multiple source possible # possibilities have already been printed sys.exit(1) if err == synctool_overlay.OV_NOT_FOUND: stderr("no such task '%s'" % filename) return run_command(obj.src_path) unix_out('')
def diff_files(filename): '''display a diff of the file''' if not synctool_param.DIFF_CMD: stderr('error: diff_cmd is undefined in %s' % synctool_param.CONF_FILE) return synctool_lib.DRY_RUN = True # be sure that it doesn't do any updates (obj, err) = synctool_overlay.find_terse(synctool_overlay.OV_OVERLAY, filename) if err == synctool_overlay.OV_FOUND_MULTIPLE: # multiple source possible # possibilities have already been printed sys.exit(1) if err == synctool_overlay.OV_NOT_FOUND: return if synctool_lib.UNIX_CMD: unix_out('%s %s %s' % (synctool_param.DIFF_CMD, obj.dest_path, obj.src_path)) else: verbose('%s %s %s' % (synctool_param.DIFF_CMD, obj.dest_path, obj.print_src())) sys.stdout.flush() sys.stderr.flush() if use_subprocess: cmd_arr = shlex.split(synctool_param.DIFF_CMD) cmd_arr.append(obj.dest_path) cmd_arr.append(obj.src_path) subprocess.Popen(cmd_arr, shell=False) else: os.system('%s %s %s' % (synctool_param.DIFF_CMD, obj.dest_path, obj.src_path)) sys.stdout.flush() sys.stderr.flush()
def master_scp(rank, args): (nodes, scp_cmd_arr, files_str) = args node = nodes[rank] nodename = NODESET.get_nodename_from_interface(node) # master thread only displays what we're running if DESTDIR: verbose("copying %s to %s:%s" % (files_str, nodename, DESTDIR)) if SCP_OPTIONS: unix_out("%s %s %s %s:%s" % (synctool_param.SCP_CMD, SCP_OPTIONS, files_str, node, DESTDIR)) else: unix_out("%s %s %s:%s" % (synctool_param.SCP_CMD, files_str, node, DESTDIR)) else: verbose("copying %s to %s" % (files_str, nodename)) if SCP_OPTIONS: unix_out("%s %s %s %s:" % (synctool_param.SCP_CMD, SCP_OPTIONS, files_str, node)) else: unix_out("%s %s %s:" % (synctool_param.SCP_CMD, files_str, node))
def run_command_in_dir(dest_dir, cmd): '''change directory to dest_dir, and run the shell command''' verbose(' os.chdir(%s)' % dest_dir) unix_out('cd %s' % dest_dir) cwd = os.getcwd() # if dry run, the target directory may not exist yet (mkdir has not been called for real, for a dry run) if synctool_lib.DRY_RUN: run_command(cmd) verbose(' os.chdir(%s)' % cwd) unix_out('cd %s' % cwd) unix_out('') return try: os.chdir(dest_dir) except OSError, reason: stderr('error changing directory to %s: %s' % (dest_dir, reason))
def symlink_file(self, oldpath): self.mkdir_basepath() # note that old_path is the readlink() of the self.src_path newpath = self.dest_path if self.dest_exists(): unix_out('mv %s %s.saved' % (newpath, newpath)) # # actually, if we want the ownership of the symlink to be correct, # we should do setuid() here # matching ownerships of symbolic links is not yet implemented # # linux makes all symlinks mode 0777, but some other platforms do not umask_mode = synctool_param.SYMLINK_MODE ^ 0777 unix_out('umask %03o' % umask_mode) unix_out('ln -s %s %s' % (oldpath, newpath)) if not synctool_lib.DRY_RUN: if self.dest_exists(): verbose('saving %s as %s.saved' % (newpath, newpath)) try: os.rename(newpath, '%s.saved' % newpath) except OSError, reason: stderr('failed to save %s as %s.saved : %s' % (newpath, newpath, reason)) terse(synctool_lib.TERSE_FAIL, 'save %s.saved' % newpath) old_umask = os.umask(umask_mode) verbose(' os.symlink(%s, %s)' % (oldpath, newpath)) try: os.symlink(oldpath, newpath) except OSError, reason: stderr('failed to create symlink %s -> %s : %s' % (newpath, oldpath, reason)) terse(synctool_lib.TERSE_FAIL, 'link %s' % newpath)
run_command(cmd) verbose(' os.chdir(%s)' % cwd) unix_out('cd %s' % cwd) unix_out('') return try: os.chdir(dest_dir) except OSError, reason: stderr('error changing directory to %s: %s' % (dest_dir, reason)) else: run_command(cmd) verbose(' os.chdir(%s)' % cwd) unix_out('cd %s' % cwd) unix_out('') try: os.chdir(cwd) except OSError, reason: stderr('error changing directory to %s: %s' % (cwd, reason)) def run_post(src, dest): '''run any on_update or .post script commands for destination path''' global DIR_CHANGED stat = synctool_stat.SyncStat(dest)
def main(): action = get_options() synctool_config.add_myhostname() if synctool_param.NODENAME == None: stderr('unable to determine my nodename, please check %s' % synctool_param.CONF_FILE) sys.exit(1) if synctool_param.NODENAME in synctool_param.IGNORE_GROUPS: stderr('%s: node %s is disabled in the config file' % (synctool_param.CONF_FILE, synctool_param.NODENAME)) sys.exit(1) synctool_config.remove_ignored_groups() synctool_param.MY_GROUPS = synctool_config.get_my_groups() synctool_param.ALL_GROUPS = synctool_config.make_all_groups() if synctool_lib.UNIX_CMD: t = time.localtime(time.time()) unix_out('#') unix_out('# script generated by synctool on %04d/%02d/%02d %02d:%02d:%02d' % (t[0], t[1], t[2], t[3], t[4], t[5])) unix_out('#') unix_out('# NODENAME=%s' % synctool_param.NODENAME) unix_out('# HOSTNAME=%s' % synctool_param.HOSTNAME) unix_out('# MASTERDIR=%s' % synctool_param.MASTERDIR) unix_out('# SYMLINK_MODE=0%o' % synctool_param.SYMLINK_MODE) unix_out('#') if not synctool_lib.DRY_RUN: unix_out('# NOTE: --fix specified, applying updates') unix_out('#') unix_out('') else: if not synctool_lib.QUIET: verbose('my nodename: %s' % synctool_param.NODENAME) verbose('my hostname: %s' % synctool_param.HOSTNAME) verbose('masterdir: %s' % synctool_param.MASTERDIR) verbose('symlink_mode: 0%o' % synctool_param.SYMLINK_MODE) if synctool_param.LOGFILE != None and not synctool_lib.DRY_RUN: verbose('logfile: %s' % synctool_param.LOGFILE) verbose('') if synctool_lib.DRY_RUN: stdout('DRY RUN, not doing any updates') terse(synctool_lib.TERSE_DRYRUN, 'not doing any updates') else: stdout('--fix specified, applying changes') terse(synctool_lib.TERSE_FIXING, ' applying changes') verbose('') synctool_lib.openlog() os.putenv('SYNCTOOL_NODENAME', synctool_param.NODENAME) os.putenv('SYNCTOOL_MASTERDIR', synctool_param.MASTERDIR) if action == ACTION_DIFF: for file in SINGLE_FILES: diff_files(file) elif action == ACTION_RUN_TASKS: if SINGLE_FILES: for single_file in SINGLE_FILES: single_task(single_file) else: run_tasks() elif action == ACTION_REFERENCE: for file in SINGLE_FILES: reference(file) elif SINGLE_FILES: for single_file in SINGLE_FILES: (changed, src) = single_files(single_file) if changed: run_post(src, single_file) run_post_on_directories() else: overlay_files() delete_files() run_post_on_directories() always_run() unix_out('# EOB') synctool_lib.closelog()
def compare_files(self): '''see what the differences are for this SyncObject, and fix it if not a dry run self.src_path is the file in the synctool/overlay tree self.dest_path is the file in the system need_update is a local boolean saying if a path needs to be updated Return value is False when file is not changed, True when file is updated -- The structure of this long function is as follows; stat(src) this stat is 'sacred' and dest should be set accordingly stat(dest) if src is symlink: check if dest exists check if dest is symlink check if dest is dir treat dest as file fix if needed if src is directory: check if dest exists check if dest is symlink check if dest is dir treat dest as file fix if needed if src is file: check if dest exists check if dest is symlink check if dest is dir treat dest as file check filesize do md5 checksum fix if needed don't know what type src is check ownership check permissions return False''' src_path = self.src_path dest_path = self.dest_path self.src_stat() src_stat = self.src_statbuf if not src_stat: return False self.dest_stat() dest_stat = self.dest_statbuf # if not dest_stat: # pass # destination does not exist need_update = False # # if source is a symbolic link ... # if src_stat.isLink(): need_update = False try: src_link = os.readlink(src_path) except OSError, reason: stderr('failed to readlink %s : %s' % (src_path, reason)) terse(synctool_lib.TERSE_FAIL, 'readlink %s' % src_path) return False if not dest_stat.exists(): stdout('symbolic link %s does not exist' % dest_path) terse(synctool_lib.TERSE_LINK, dest_path) unix_out('# create symbolic link %s' % dest_path) need_update = True elif dest_stat.isLink(): try: dest_link = os.readlink(dest_path) except OSError, reason: stderr('failed to readlink %s : %s (but ignoring this error)' % (src_path, reason)) terse(synctool_lib.TERSE_FAIL, 'readlink %s' % src_path) dest_link = None if src_link != dest_link: stdout('%s should point to %s, but points to %s' % (dest_path, src_link, dest_link)) terse(synctool_lib.TERSE_LINK, dest_path) unix_out('# relink symbolic link %s' % dest_path) need_update = True if (dest_stat.mode & 07777) != synctool_param.SYMLINK_MODE: stdout('%s should have mode %04o (symlink), but has %04o' % (dest_path, synctool_param.SYMLINK_MODE, dest_stat.mode & 07777)) terse(synctool_lib.TERSE_MODE, '%04o %s' % (synctool_param.SYMLINK_MODE, dest_path)) unix_out('# fix permissions of symbolic link %s' % dest_path) need_update = True
def upload(interface, upload_filename, upload_suffix=None): '''copy a file from a node into the overlay/ tree''' if not synctool_param.SCP_CMD: stderr('%s: error: scp_cmd has not been defined in %s' % (os.path.basename(sys.argv[0]), synctool_param.CONF_FILE)) sys.exit(-1) if upload_filename[0] != '/': stderr('error: the filename to upload must be an absolute path') sys.exit(-1) trimmed_upload_fn = upload_filename[1:] # remove leading slash import synctool_overlay # make the known groups lists synctool_config.remove_ignored_groups() synctool_param.MY_GROUPS = synctool_config.get_my_groups() synctool_param.ALL_GROUPS = synctool_config.make_all_groups() if upload_suffix and not upload_suffix in synctool_param.ALL_GROUPS: stderr("no such group '%s'" % upload_suffix) sys.exit(-1) # shadow DRY_RUN because that var can not be used correctly here if '-f' in PASS_ARGS or '--fix' in PASS_ARGS: dry_run = False else: dry_run = True if not synctool_lib.QUIET: stdout('DRY RUN, not uploading any files') terse(synctool_lib.TERSE_DRYRUN, 'not uploading any files') node = NODESET.get_nodename_from_interface(interface) # pretend that the current node is now the given node; # this is needed for find() to find the most optimal reference for the file orig_NODENAME = synctool_param.NODENAME synctool_param.NODENAME = node synctool_config.insert_group(node, node) orig_MY_GROUPS = synctool_param.MY_GROUPS[:] synctool_param.MY_GROUPS = synctool_config.get_my_groups() # see if file is already in the repository (obj, err) = synctool_overlay.find_terse(synctool_overlay.OV_OVERLAY, upload_filename) if err == synctool_overlay.OV_FOUND_MULTIPLE: # multiple source possible # possibilities have already been printed sys.exit(1) if err == synctool_overlay.OV_NOT_FOUND: # no source path found if string.find(upload_filename, '...') >= 0: stderr("%s is not in the repository, don't know what to map this path to\n" "Please give the full path instead of a terse path, or touch the source file\n" "in the repository first and try again" % os.path.basename(upload_filename)) sys.exit(1) # it wasn't a terse path, throw a source path together # This picks the first overlay dir as default source, which may not be correct # but it is a good guess repos_filename = os.path.join(synctool_param.OVERLAY_DIRS[0], trimmed_upload_fn) if upload_suffix: repos_filename = repos_filename + '._' + upload_suffix else: repos_filename = repos_filename + '._' + node # use _nodename as default suffix else: if upload_suffix: # remove the current group suffix an add the specified suffix to the filename arr = string.split(obj.src_path, '.') if len(arr) > 1 and arr[-1][0] == '_': repos_filename = string.join(arr[:-1], '.') repos_filename = repos_filename + '._' + upload_suffix else: repos_filename = obj.src_path synctool_param.NODENAME = orig_NODENAME synctool_param.MY_GROUPS = orig_MY_GROUPS verbose('%s:%s uploaded as %s' % (node, upload_filename, repos_filename)) terse(synctool_lib.TERSE_UPLOAD, repos_filename) unix_out('%s %s:%s %s' % (synctool_param.SCP_CMD, interface, upload_filename, repos_filename)) if dry_run: stdout('would be uploaded as %s' % synctool_lib.prettypath(repos_filename)) else: # first check if the directory in the repository exists repos_dir = os.path.dirname(repos_filename) stat = synctool_stat.SyncStat(repos_dir) if not stat.exists(): verbose('making directory %s' % synctool_lib.prettypath(repos_dir)) unix_out('mkdir -p %s' % repos_dir) synctool_lib.mkdir_p(repos_dir) # make scp command array scp_cmd_arr = shlex.split(synctool_param.SCP_CMD) scp_cmd_arr.append('%s:%s' % (interface, upload_filename)) scp_cmd_arr.append(repos_filename) synctool_lib.run_with_nodename(scp_cmd_arr, NODESET.get_nodename_from_interface(interface)) if os.path.isfile(repos_filename): stdout('uploaded %s' % synctool_lib.prettypath(repos_filename))
need_update = True elif dest_stat.isDir(): stdout('%s should be a symbolic link' % dest_path) terse(synctool_lib.TERSE_LINK, dest_path) unix_out('# target should be a symbolic link') self.save_dir() need_update = True # # treat as file ... # else: stdout('%s should be a symbolic link' % dest_path) terse(synctool_lib.TERSE_LINK, dest_path) unix_out('# target should be a symbolic link') need_update = True # # (re)create the symbolic link # if need_update: self.symlink_file(src_link) unix_out('') return True # # if the source is a directory ... # elif src_stat.isDir(): if not dest_stat.exists():
def always_run(): '''always run these commands''' for cmd in synctool_param.ALWAYS_RUN: run_command(cmd) unix_out('')
need_update = True elif dest_stat.isDir(): stdout("%s should be a symbolic link" % dest_path) terse(synctool_lib.TERSE_LINK, dest_path) unix_out("# target should be a symbolic link") self.save_dir() need_update = True # # treat as file ... # else: stdout("%s should be a symbolic link" % dest_path) terse(synctool_lib.TERSE_LINK, dest_path) unix_out("# target should be a symbolic link") need_update = True # # (re)create the symbolic link # if need_update: self.symlink_file(src_link) unix_out("") return True # # if the source is a directory ... # elif src_stat.isDir(): if not dest_stat.exists():
def tasks_callback(obj): '''run tasks''' if not obj.src_isDir(): run_command(obj.src_path) unix_out('')