def check_for_cmd(cmd): """Make sure that a program necessary for using this script is available. Arguments: cmd -- string or list of strings of commands. A single string may not contain spaces. Returns: Nothing """ # Display input parameters start_time = get_clock() logging.info('Entered function') logging.debug('cmd: %s', cmd) # Ensure there are no embedded spaces in a string command if isinstance(cmd, str) and ' ' in cmd: end_time = get_clock() logging.error('Exiting - embedded space in command') logging.info('Elapsed time: %f', (end_time - start_time)) exit(1) # Execute the command execute_cmd(cmd=cmd, cmd_source='check_for_cmd') end_time = get_clock() logging.info('Elapsed time: %f', (end_time - start_time))
def git_ls_files(): """Find files that are relevant based on all files for the repository branch. Arguments: None Returns: A list of filenames. """ # Display input parameters start_time = get_clock() logging.info('Entered function') cmd = ['git', 'ls-files'] # Get a list of all files in the current repository branch cmd_stdout = execute_cmd(cmd=cmd, cmd_source='git_ls_files') end_time = get_clock() logging.info('Elapsed time: %f', (end_time - start_time)) # Return from the function return cmd_stdout
def execute_cmd(cmd, cmd_source=None): """Execute the supplied program. Arguments: cmd -- string or list of strings of commands. A single string may not contain spaces. cmd_source -- The function requesting the program execution. Default value of None. Returns: Process stdout file handle """ # Display input parameters start_time = get_clock() logging.info('Entered function') logging.debug('cmd: %s', cmd) logging.debug('cmd_source: %s', cmd_source) # Ensure there are no embedded spaces in a string command if isinstance(cmd, str) and ' ' in cmd: end_time = get_clock() logging.error('Exiting - embedded space in command') logging.info('Elapsed time: %f', (end_time - start_time)) exit(1) # Execute the command try: cmd_handle = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (cmd_stdout, cmd_stderr) = cmd_handle.communicate() logging.info('Command %s successfully executed', cmd) if cmd_stderr: for line in cmd_stderr.strip().decode("utf-8").splitlines(): logging.info("stderr line: %s", line) # If the command fails, notify the user and exit immediately except subprocess.CalledProcessError as err: end_time = get_clock() logging.info("Program %s call failed! -- Exiting.", cmd, exc_info=True) logging.error("Program %s call failed! -- Exiting.", cmd) logging.info('Elapsed time: %f', (end_time - start_time)) raise except OSError as err: end_time = get_clock() logging.info("Program %s caused on OS error! -- Exiting.", cmd, exc_info=True) logging.error("Program %s caused OS error %s! -- Exiting.", cmd, err.errno) logging.info('Elapsed time: %f', (end_time - start_time)) raise end_time = get_clock() logging.info('Elapsed time: %f', (end_time - start_time)) # Return from the function return cmd_stdout
def get_checkout_files(first_hash, second_hash): """Find files that have been modified over the range of the supplied commit hashes. Arguments: first_hash - The starting hash of the range second_hash - The ending hash of the range Returns: A list of filenames. """ # Display input parameters start_time = get_clock() logging.debug('Entered function') logging.debug('First hash: %s', first_hash) logging.debug('Second hash: %s', second_hash) file_list = [] # Get the list of files impacted. If argv[1] and argv[2] are the same # commit, then pass the value only once otherwise the file list is not # returned if first_hash == second_hash: cmd = [ 'git', 'diff-tree', '-r', '--name-only', '--no-commit-id', '--diff-filter=ACMRT', first_hash ] else: cmd = [ 'git', 'diff-tree', '-r', '--name-only', '--no-commit-id', '--diff-filter=ACMRT', first_hash, second_hash ] # Fetch the list of files modified by the last commit cmd_stdout = execute_cmd(cmd=cmd, cmd_source='get_checkout_files') # Convert the stdout stream to a list of files file_list = cmd_stdout.decode('utf8').splitlines() # Deal with unmodified repositories if file_list and file_list[0] == 'clean': end_time = get_clock() logging.info('No files to process') logging.info('Elapsed time: %f', (end_time - start_time)) exit(0) # Only return regular files. file_list = [i for i in file_list if os.path.isfile(i)] end_time = get_clock() logging.debug('Returning file list to process %s', file_list) logging.info('Elapsed time: %f', (end_time - start_time)) # Return from the function return file_list
def post_checkout(): """Main program. Arguments: argv: command line arguments Returns: Nothing """ # Display input parameters start_time = get_clock() logging.info('Entered function') logging.debug('sys.argv: %s', sys.argv) # If argv[3] is zero (file checkout rather than branch checkout), # then exit the hook as there is no need to re-smudge the file. # (The commit info was already available) If the vallue is 1, then # this is a branch checkout and commit info was not available at the # time the file was checkted out. if sys.argv[3] == '0': end_time = get_clock() logging.debug('File checkout - no work required') logging.info('Elapsed time: %f', (end_time - start_time)) exit(0) # Check if git is available. check_for_cmd(cmd=['git', '--version']) # Get the list of files impacted. files = get_checkout_files(first_hash=sys.argv[1], second_hash=sys.argv[2]) logging.debug('Files to checkout: %s', files) # Filter the list of modified files to exclude those modified since # the commit files = remove_modified_files(files=files) logging.debug('Non-modified files: %s', files) # Force a checkout of the remaining file list files_processed = 0 if files: files.sort() for file_name in files: logging.info('Checking out file %s', file_name) check_out_file(file_name=file_name) files_processed += 1 sys.stderr.write('Smudged file %s\n' % file_name) logging.info('Checked out file %s', file_name) end_time = get_clock() logging.info('Elapsed time: %f', (end_time - start_time))
def remove_modified_files(files): """Filter the found files to eliminate any that have changes that have not been checked in. Arguments: files - list of files to checkout Returns: A list of files to checkout that do not have pending changes. """ # Display input parameters start_time = get_clock() logging.info('Entered function') logging.debug('files: %s', files) cmd = ['git', 'status', '-s'] # Get the list of files that are modified but not checked in cmd_stdout = execute_cmd(cmd=cmd, cmd_source='remove_modified_files') # Convert the stream output to a list of output lines modified_files_list = cmd_stdout.decode('utf8').splitlines() # Deal with unmodified repositories if not modified_files_list: end_time = get_clock() logging.info('No modified files found') logging.info('Elapsed time: %f', (end_time - start_time)) return files # Pull the file name (second field) of the output line and # remove any double quotes modified_files_list = [ l.split(None, 1)[-1].strip('"') for l in modified_files_list ] logging.debug('Modified files list: %s', modified_files_list) # Remove any modified files from the list of files to process if modified_files_list: files = [f for f in files if f not in modified_files_list] end_time = get_clock() logging.debug('files: %s', files) logging.info('Elapsed time: %f', (end_time - start_time)) # Return from the function return files
def fader_start(self, *args): """ Start fading process :param args: *args (OrderedDict or int x4): Arguments passed to fade_init """ self.fRun, self.fFinished = True, False self.fade_init(*args) self._fTimeUpdate = get_clock() self.fHandler_start()
def process_hooks(): """Main program. Returns: Nothing """ # Display the parameters passed on the command line start_time = get_clock() logging.info('Entered function') logging.debug('sys.argv parameter count %d', len(sys.argv)) logging.debug('sys.argv parameters %s', sys.argv) # Verify that the named hook directory is a directory list_dir = sys.argv[0] + '.d' if not os.path.isdir(list_dir): logging.info('The hook directory %s is not a directory', list_dir) exit(0) # Execute each of the hooks found in the relevant directory hook_count = 0 hook_executed = 0 for file_name in sorted(os.listdir(list_dir)): hook_count += 1 hook_program = os.path.join(list_dir, file_name) if os.path.isfile(hook_program) and os.access(hook_program, os.X_OK): # If parameters were supplied, pass them through to the actual # hook program if len(sys.argv) > 1: hook_program = '"%s" %s' \ % (hook_program, ' '.join('"%s"' % param for param in sys.argv[1:])) hook_executed += 1 logging.info('Executing hook %s', hook_program) hook_call = subprocess.call([hook_program], shell=True) if hook_call > 0: end_time = get_clock() logging.info('Exiting - Hook program failed with error %s', hook_call) logging.info('Elapsed time: %f', (end_time - start_time)) exit(hook_call) end_time = get_clock() logging.debug('Hooks examined: %d', hook_count) logging.debug('Hooks executed: %d', hook_executed) logging.info('Elapsed time: %f', (end_time - start_time))
def post_rewrite(): """Main program. Arguments: argv: command line arguments Returns: Nothing """ start_time = get_clock() logging.info('Entered function') # Check if git is available. check_for_cmd(cmd=['git', '--version']) # Read stdin and write it to stderr input_lines = sys.stdin.readlines() line_count = 1 files = [] for source_line in input_lines: line_count += 1 words = source_line.split() # Get the list of modified files files = files + get_modified_files(dest_hash=words[1].strip()) logging.debug('Files: %s', files) # Check if git is available. check_for_cmd(cmd=['git', '--version']) # Force a checkout of the remaining file list files_processed = 0 if files: for file_name in sorted(files): check_out_file(file_name=file_name) files_processed += 1 sys.stderr.write('Smudged file %s\n' % file_name) logging.info('Checked out file %s', file_name) logging.debug('Files processed: %s', files_processed) end_time = get_clock() logging.info('Elapsed time: %f', (end_time - start_time))
def get_modified_files(): """Find files that were modified by the commit. Arguments: None Returns: A list of filenames. """ # Display input parameters start_time = get_clock() logging.debug('Entered function') modified_file_list = [] cmd = [ 'git', 'diff-tree', 'HEAD~1', 'HEAD', '--name-only', '-r', '--diff-filter=ACMRT' ] # Fetch the list of files modified by the last commit cmd_stdout = execute_cmd(cmd=cmd, cmd_source='get_modified_files') # Convert the stdout stream to a list of files modified_file_list = cmd_stdout.decode('utf8').splitlines() logging.debug('modified_file_list: %s', cmd) # Deal with unmodified repositories if modified_file_list and modified_file_list[0] == 'clean': end_time = get_clock() logging.info('No modified files found') logging.info('Elapsed time: %f', (end_time - start_time)) exit(0) # Only return regular files. modified_file_list = [i for i in modified_file_list if os.path.isfile(i)] end_time = get_clock() logging.debug('modified_file_list: %s', cmd) logging.info('Elapsed time: %f', (end_time - start_time)) # Return from the function return modified_file_list
def check_out_file(file_name): """Checkout file that was been modified by the latest merge. Arguments: file_name -- the file name to be checked out for smudging Returns: Nothing. """ start_time = get_clock() logging.info('Entered function') logging.debug('file_name: %s', file_name) # Remove the file if it currently exists try: os.remove(file_name) except OSError as err: # Ignore a file not found error, it was being removed anyway if err.errno != errno.ENOENT: end_time = get_clock() logging.info( "File removal of %s caused on OS error %d! -- Exiting.", file_name, err.errno, exc_info=True ) logging.error( "File removal %s caused OS error %d! -- Exiting.", file_name, err.errno ) logging.info('Elapsed time: %f', (end_time - start_time)) exit(err.errno) cmd = ['git', 'checkout', '-f', '%s' % file_name] # Check out the file so that it is smudged execute_cmd(cmd=cmd, cmd_source='check_out_files') end_time = get_clock() logging.info('Elapsed time: %f', (end_time - start_time))
def post_commit(): """Main program. Arguments: None Returns: Nothing """ # Display input parameters start_time = get_clock() logging.info('Entered function') # Check if git is available. check_for_cmd(cmd=['git', '--version']) # Get the list of modified files committed_files = get_modified_files() logging.debug('committed_files: %s', committed_files) # Filter the list of modified files to exclude those modified since # the commit committed_files = remove_modified_files(files=committed_files) logging.debug('committed_files: %s', committed_files) # Force a checkout of the remaining file list # Process the remaining file list files_processed = 0 if committed_files: committed_files.sort() for file_name in committed_files: check_out_file(file_name=file_name) files_processed += 1 sys.stderr.write('Smudged file %s\n' % file_name) logging.info('Checked out file %s', file_name) end_time = get_clock() logging.debug('files processed: %s', files_processed) logging.info('Elapsed time: %f', (end_time - start_time))
def fade_inc(self): """ Fading thread (handles increments) """ while 1: if self._fHandler_en is True: now = get_clock() if (now - self._fTimeUpdate) >= self._fTimeInc: self._fTimeUpdate = now if not self.fFinished: try: next(self) except StopIteration: pass
def check_out_file(file_name): """Checkout file that was been modified by the latest branch checkout. Arguments: file_name -- the file name to be checked out for smudging Returns: Nothing. """ # Display input parameters start_time = get_clock() logging.info('Entered function') logging.debug('File_name: %s', file_name) # Remove the file if it currently exists try: os.remove(file_name) logging.info('Removed file %s', file_name) except OSError as err: # Ignore a file not found error, it was being removed anyway if err.errno != errno.ENOENT: end_time = get_clock() logging.error('Unable to remove file %s for re-checkout', file_name) logging.info('Elapsed time: %f', (end_time - start_time)) exit(err.errno) else: logging.info('File %s not found to remove', file_name) cmd = ['git', 'checkout', '-f', '%s' % file_name] # Check out the file so that it is smudged execute_cmd(cmd=cmd, cmd_source='check_out_files') logging.info('Checked out file %s', file_name) end_time = get_clock() logging.info('Elapsed time: %f', (end_time - start_time))
def smudge_input(): """Main program. Arguments: argv: command line arguments Returns: Nothing """ # Display the parameters passed on the command line if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: start_time = get_clock() logging.debug('') logging.debug('Function: %s' % sys._getframe().f_code.co_name) logging.debug('sys.argv parameter count %d' % len(sys.argv)) logging.debug('sys.argv parameters %s' % sys.argv) # Calculate the source file being smudged if len(sys.argv) > 1: file_name = sys.argv[1] else: file_name = '<Unknown file>' # Log the results of the git log operation if LOGGING_LEVEL: logging.debug('Display the file name parameter %s' % file_name) # Define the fields to be extracted from the commit log git_field_name = [ 'hash', 'author_name', 'author_email', 'commit_date', 'short_hash' ] git_field_log = ['%H', '%an', '%ae', '%ci', '%h'] # Define the various substitution regular expressions author_regex = re.compile(r"\$Author: +[.\w@<> ]+ +\$|\$Author\$", re.IGNORECASE) id_regex = re.compile(r"\$Id: +.+ \| [-:\d ]+ \| .+ +\$|\$Id\$", re.IGNORECASE) date_regex = re.compile(r"\$Date: +[-:\d ]+ +\$|\$Date\$", re.IGNORECASE) source_regex = re.compile(r"\$Source: .+[.].+ \$|\$Source\$", re.IGNORECASE) file_regex = re.compile(r"\$File: .+[.].+ \$|\$File\$", re.IGNORECASE) revision_regex = re.compile(r"\$Revision: +[-:\d ]+ +\$|\$Revision\$", re.IGNORECASE) rev_regex = re.compile(r"\$Rev: +[-:\d ]+ +\$|\$Rev\$", re.IGNORECASE) hash_regex = re.compile(r"\$Hash: +\w+ +\$|\$Hash\$", re.IGNORECASE) regex_dict = {} # Process each of the rows found on stdin line_count = 0 try: for line in sys.stdin: line_count += 1 if line.count('$') > 1: if len(regex_dict) == 0: regex_dict = build_regex_dict( git_field_log=git_field_log, file_name=file_name, git_field_name=git_field_name) line = author_regex.sub(regex_dict['git_author'], line) line = id_regex.sub(regex_dict['git_id'], line) line = date_regex.sub(regex_dict['git_date'], line) line = source_regex.sub(regex_dict['git_source'], line) line = file_regex.sub(regex_dict['git_file'], line) line = revision_regex.sub(regex_dict['git_revision'], line) line = rev_regex.sub(regex_dict['git_rev'], line) line = hash_regex.sub(regex_dict['git_hash'], line) sys.stdout.write(line) except Exception: logging.error('Exception smudging file %s' % file_name, exc_info=True) sys.stderr.write( 'Exception smudging file %s - Key words were not replaced\n' % file_name) exit(2) if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: end_time = get_clock() logging.info('Line count in %s: %s' % (sys._getframe().f_code.co_name, line_count)) logging.info('Elapsed for %s: %s' % (sys._getframe().f_code.co_name, end_time - start_time))
def build_regex_dict(git_field_log, file_name, git_field_name): """Function to converts a 1 row list of git log attributes into dictionary of regex expressions. Arguments: git_field_log -- a list of git log fields to capture file_name -- The full file name to be examined git_field_name -- Name of the attributes fields for the dictionary Returns: regex_dict -- Array of defined attribute dictionaries """ # Display input parameters if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: start_time = get_clock() logging.debug('') logging.debug('Function: %s' % sys._getframe().f_code.co_name) logging.debug('git_field_log %s' % git_field_log) logging.debug('file_name: %s' % file_name) logging.debug('git_field_name: %s' % git_field_name) # Format the git log command git_log = git_log_attributes(git_field_log=git_field_log, file_name=file_name, git_field_name=git_field_name) if not git_log: logging.error('No git attributes returned: %s' % sys._getframe().f_code.co_name) exit(4) if len(git_log) > 1: logging.error('More than one row of git attributes returned: %s' % sys._getframe().f_code.co_name) exit(3) regex_dict = {} if git_log: # Calculate the replacement strings based on the git log results # Deal with values in author name that have a Windows domain name if '\\' in git_log[0]['author_name']: git_log[0]['author_name'] = git_log[0]['author_name'].split( '\\')[-1] regex_dict['git_hash'] = '$Hash: %s $' % str(git_log[0]['hash']) regex_dict['git_short_hash'] = '$Short Hash: %s $' % str( git_log[0]['short_hash']) regex_dict['git_author'] = '$Author: %s <%s> $' % (str( git_log[0]['author_name']), str(git_log[0]['author_email'])) regex_dict['git_date'] = '$Date: %s $' % str( git_log[0]['commit_date']) regex_dict['git_rev'] = '$Rev: %s $' % str( git_log[0]['commit_date']) regex_dict['git_revision'] = '$Revision: %s $' % str( git_log[0]['commit_date']) regex_dict['git_file'] = '$File: %s $' % str(file_name) regex_dict['git_source'] = '$Source: %s $' % str(file_name) regex_dict['git_id'] = '$Id: %s | %s | %s $' % ( str(file_name), str( git_log[0]['commit_date']), str(git_log[0]['author_name'])) else: # Build a empty keyword list if no source data was found # Note: the unusual means of building the list is to keep # the code from being modified while using keywords! regex_dict['git_hash'] = '$%s$' % 'Hash' regex_dict['git_author'] = '$%s$' % 'Author' regex_dict['git_date'] = '$%s$' % 'Date' regex_dict['git_rev'] = '$%s$' % 'Rev' regex_dict['git_revision'] = '$%s$' % 'Revision' regex_dict['git_file'] = '$%s$' % 'File' regex_dict['git_source'] = '$%s$' % 'Source' regex_dict['git_id'] = '$%s$' % 'Id' # Log the results of the git log operation if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: end_time = get_clock() logging.info('Elapsed for %s: %s' % (sys._getframe().f_code.co_name, end_time - start_time)) logging.debug('regex_dict: %s' % regex_dict) return regex_dict
'Exception smudging file %s - Key words were not replaced\n' % file_name) exit(2) if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: end_time = get_clock() logging.info('Line count in %s: %s' % (sys._getframe().f_code.co_name, line_count)) logging.info('Elapsed for %s: %s' % (sys._getframe().f_code.co_name, end_time - start_time)) # Execute the main function if __name__ == '__main__': # Initialize logging if LOGGING_LEVEL: if LOGGING_LEVEL <= logging.INFO: start_time = get_clock() logging.basicConfig(level=LOGGING_LEVEL, format='%(levelname)s: %(message)s', filename='.git-hook.smudge.log') logging.debug('') logging.debug('') logging.debug('Executing: %s' % sys.argv[0]) smudge_input() if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: end_time = get_clock() logging.info('Elapsed for %s: %s' % (sys.argv[0], end_time - start_time))
def fader_resume(self): """ Resume fading process """ self.fRun = True self._fTimeUpdate = get_clock() self.fHandler_start()
def clean_input(): """Main program. Arguments: argv: command line arguments Returns: Nothing """ # Display the parameters passed on the command line if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: start_time = get_clock() logging.debug('') logging.debug('Function: %s' % sys._getframe().f_code.co_name) logging.debug('sys.argv parameter count %d' % len(sys.argv)) logging.debug('sys.argv parameters %s' % sys.argv) # Calculate the source file being cleaned if len(sys.argv) > 1: file_name = sys.argv[1] else: file_name = '<Unknown file>' # Define the various substitution regular expressions author_regex = re.compile(r"\$Author:.*\$", re.IGNORECASE) id_regex = re.compile(r"\$Id: +.+ \| [-:\d ]+ \| .+ +\$|\$Id\$", re.IGNORECASE) date_regex = re.compile(r"\$Date: +[-:\d ]+ +\$|\$Date\$", re.IGNORECASE) source_regex = re.compile(r"\$Source: .+[.].+ \$|\$Source\$", re.IGNORECASE) file_regex = re.compile(r"\$File: .+[.].+ \$|\$File\$", re.IGNORECASE) revision_regex = re.compile(r"\$Revision: +[-:\d+ ]+ +\$|\$Revision\$", re.IGNORECASE) rev_regex = re.compile(r"\$Rev: +[-:\d+ ]+ +\$|\$Rev\$", re.IGNORECASE) hash_regex = re.compile(r"\$Hash: +\w+ +\$|\$Hash\$", re.IGNORECASE) # Calculate empty strings based on the keyword git_hash = '$%s$' % 'Hash' git_author = '$%s$' % 'Author' git_date = '$%s$' % 'Date' git_rev = '$%s$' % 'Rev' git_revision = '$%s$' % 'Revision' git_file = '$%s$' % 'File' git_source = '$%s$' % 'Source' git_id = '$%s$' % 'Id' # Process each of the rows found on stdin line_count = 0 try: for line in sys.stdin: line_count += 1 if line.count('$') > 1: line = author_regex.sub(git_author, line) line = id_regex.sub(git_id, line) line = date_regex.sub(git_date, line) line = source_regex.sub(git_source, line) line = file_regex.sub(git_file, line) line = revision_regex.sub(git_revision, line) line = rev_regex.sub(git_rev, line) line = hash_regex.sub(git_hash, line) sys.stdout.write(line) except Exception: logging.error('Exception cleaning file %s' % file_name, exc_info=True) sys.stderr.write( 'Exception smudging file %s - Key words were not replaced\n' % file_name) exit(2) if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: end_time = get_clock() logging.info('Line count in %s: %s' % (sys._getframe().f_code.co_name, line_count)) logging.info('Elapsed for %s: %s' % (sys._getframe().f_code.co_name, end_time - start_time))
def git_log_attributes(git_field_log, file_name, git_field_name): """Function to dump the git log associated with the provided file name. Arguments: git_field_log -- a list of git log fields to capture file_name -- The full file name to be examined git_field_name -- Name of the attributes fields for the dictionary Returns: git_log -- List of defined attribute dictionaries """ # Display input parameters if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: start_time = get_clock() logging.debug('') logging.debug('Function: %s' % sys._getframe().f_code.co_name) logging.debug('git_field_log %s' % git_field_log) logging.debug('file_name: %s' % file_name) logging.debug('git_field_name: %s' % git_field_name) # Format the git log command git_field_format = '%x1f'.join(git_field_log) + '%x1e' cmd = [ 'git', 'log', '--date=iso8601', '--max-count=1', '--format=%s' % git_field_format, '--', str(file_name) ] # Process the git log command try: cmd_handle = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (cmd_stdout, cmd_stderr) = cmd_handle.communicate() if cmd_stderr: for line in cmd_stderr.strip().decode("utf-8").splitlines(): sys.stderr.write("%s\n" % line) # If the command fails, notify the user and exit immediately except subprocess.CalledProcessError as err: sys.stderr.write( "{0} - Program {1} called by {2} not found! -- Exiting.".format( str(err), str(cmd[0]), str(' '.join(cmd)))) # shutdown_message(return_code=err.returncode) exit(err.returncode) except OSError as err: sys.stderr.write( "{0} - Program {1} called by {2} not found! -- Exiting.".format( str(err), str(cmd[0]), str(' '.join(cmd)))) # shutdown_message(return_code=err.errno) exit(err.errno) # If an error occurred, display the command output and exit # with the returned exit code if cmd_handle.returncode != 0: sys.stderr.write("Exiting -- git log return code: %s\n" % str(cmd_handle.returncode)) sys.stderr.write("Output text: %s\n" % cmd_stdout.strip().decode("utf-8")) # shutdown_message(return_code=cmd_handle.returncode) exit(cmd_handle.returncode) # Calculate replacement strings based on the git log results if cmd_stdout: # Convert returned values to a list of dictionaries # git_log = cmd_stdout.strip().decode("utf-8") # git_log = git_log.strip().split("\x1e") git_output = cmd_stdout.strip().decode("utf-8") git_log = git_output.strip().split("\x1e") git_log = [row.strip().split("\x1f") for row in git_log] git_log = [dict(zip(git_field_name, row)) for row in git_log] else: git_log = [] # Log the results of the git log operation if LOGGING_LEVEL and LOGGING_LEVEL <= logging.INFO: end_time = get_clock() logging.info('Elapsed for %s: %s' % (sys._getframe().f_code.co_name, end_time - start_time)) logging.debug('git_log: %s' % git_log) # Return from the function return git_log
# Write a small program to display information on the # four clocks whose functions we have just looked at: # i.e. time(), perf_counter, monotonic() and process_time(). # # Use the documentation for the get_clock_info() function # to work out how to call it for each of the clocks. import time from time import get_clock_info as get_clock print("Time: {:.10}".format(get_clock('time').resolution)) print("Perf_counter: {:.20}".format(get_clock('perf_counter').resolution)) print("Monotonic: {:.10}".format(get_clock('monotonic').resolution)) print("Process_time: {:.20}".format(get_clock('process_time').resolution))
committed_files = remove_modified_files(files=committed_files) logging.debug('committed_files: %s', committed_files) # Force a checkout of the remaining file list # Process the remaining file list files_processed = 0 if committed_files: committed_files.sort() for file_name in committed_files: check_out_file(file_name=file_name) files_processed += 1 sys.stderr.write('Smudged file %s\n' % file_name) logging.info('Checked out file %s', file_name) end_time = get_clock() logging.debug('files processed: %s', files_processed) logging.info('Elapsed time: %f', (end_time - start_time)) # Execute the main function if __name__ == '__main__': configure_logging() START_TIME = get_clock() logging.debug('Entered module') post_commit() END_TIME = get_clock() logging.info('Elapsed time: %f', (END_TIME - START_TIME))