#! /usr/bin/env python3.3 """PrintHandler.""" import codecs import os import logging import tempfile from P4 import OutputHandler, P4Exception import p4gf_git from p4gf_l10n import _ from p4gf_p2g_rev_list import RevList from p4gf_p4file import P4File import p4gf_progress_reporter as ProgressReporter import p4gf_pygit2 import p4gf_util LOG = logging.getLogger('p4gf_copy_to_git').getChild('print_handler') class PrintHandler(OutputHandler): """OutputHandler for p4 print, hashes files into git repo.""" def __init__(self, ctx): """Initialize the PrintHandler instance.""" OutputHandler.__init__(self) self.rev = None # a P4File self.revs = RevList() self.temp_file = None self.p4 = ctx.p4 self.p4gf = ctx.p4gf self.change_set = set() self.repo = ctx.repo self.ctx = ctx def outputBinary(self, h): """Assemble file content, then pass it to hasher via temp file.""" try: LOG.debug3('outputBinary() called with {} bytes'.format(len(h))) self.appendContent(h) except Exception: # pylint: disable=broad-except LOG.exception("outputBinary") return OutputHandler.HANDLED def outputText(self, h): """Assemble file content, then pass it to hasher via temp file. Either str or bytearray can be passed to outputText. Since we need to write this to a file and calculate a SHA1, we need bytes. For unicode servers, we have a charset specified which is used to convert a str to bytes. For a nonunicode server, we will have specified "raw" encoding to P4Python, so we should never see a str. """ try: if self.p4.charset and self.p4.charset != 'none': try: # self.p4.__convert() doesn't work correctly here if type(h) == str: b = getattr(self.p4, '__convert')(self.p4.charset, h) else: b = getattr(self.p4, '__convert')(self.p4.charset, h.decode()) except: raise P4Exception( _("error: failed '{charset}' conversion for '{path}#{rev}'") .format(charset=self.p4.charset, path=self.rev.depot_path, rev=self.rev.revision)) else: if type(h) == str: raise RuntimeError(_('unexpected outputText')) b = h LOG.debug3('outputText() called with {} bytes'.format(len(b))) self.appendContent(b) except Exception: # pylint: disable=broad-except LOG.exception("outputText") return OutputHandler.HANDLED def appendContent(self, h): # pylint: disable=invalid-name """Append a chunk of content to the temp file. It would be nice to incrementally compress and hash the file but that requires knowing the size up front, which p4 print does not currently supply. If/when it does, this can be reworked to be more efficient with large files. As it is, as long as the TemporaryFile doesn't rollover, it won't make much of a difference. So with that limitation, the incoming content is stuffed into a TemporaryFile. """ if not len(h): return if self.temp_file is None: LOG.warning('outputBinary/outputText called before outputStat, nothing can be done') # In fact, we don't even have the file meta information, so we # cannot provide any details for debugging this issue. return self.temp_file.write(h) def flush(self): """Hash the last printed file into the repo.""" if not self.rev: LOG.debug3('flush() nothing to flush') return size = self.temp_file.tell() if size > 0 and self.rev.is_symlink(): # p4 print adds a trailing newline, which is no good for symlinks. self.temp_file.seek(-1, 2) b = self.temp_file.read(1) if b[0] == 10: size = self.temp_file.truncate(size - 1) self.temp_file.close() # p4.charset could be None, empty string, or 'none' if (not self.p4.charset or self.p4.charset == 'none') and 'utf16' in self.rev.type: # Convert UTF-8 encoded files to UTF-16, but only for non- # Unicode servers, in which case we would have already handled # the conversion in the outputText() function. LOG.debug('flush() converting {} to UTF-16'.format(self.rev.depot_path)) with open(self.temp_file.name, 'r', encoding="utf8") as fobj: temp_str = fobj.read() # Include a Byte Order Mark (why doesn't P4API do this for # us?). The choice of Little Endian is arbitrary, since we are # including the BOM anyway. Regardless, it is not possible to # know the endianness of the client, but LE is most likely. temp_data = getattr(self.p4, '__convert')("utf16le", temp_str) with open(self.temp_file.name, 'wb') as fobj: fobj.write(codecs.BOM_UTF16_LE) fobj.write(temp_data) LOG.debug3('flush() writing {} to Git repository'.format(self.rev.depot_path)) try: tmpname = os.path.basename(self.temp_file.name) self.rev.sha1 = p4gf_pygit2.create_blob_fromdisk(self.repo, tmpname) self.revs.append(self.rev) self._chmod_644_minimum(self.rev.sha1) except Exception: # pylint: disable=broad-except LOG.exception('failed to write blob to repository') finally: LOG.debug3('flush() removing temporary file {}'.format(self.temp_file.name)) try: os.unlink(self.temp_file.name) finally: self.temp_file = None self.rev = None def outputStat(self, h): """Save path of current file.""" try: self.flush() self.rev = P4File.create_from_print(h) self.change_set.add(self.rev.change) ProgressReporter.increment(_('Copying files')) LOG.debug2("PrintHandler.outputStat() ch={} {}#{}".format( self.rev.change, self.rev.depot_path, self.rev.revision)) # use the git working tree so we can use create_blob_fromfile() tmpdir = os.getcwd() self.temp_file = tempfile.NamedTemporaryFile( buffering=10000000, prefix='p2g-print-', dir=tmpdir, delete=False) LOG.debug3('outputStat() temporary file created: {}'.format(self.temp_file.name)) except Exception: # pylint: disable=broad-except LOG.exception("outputStat") return OutputHandler.HANDLED def outputInfo(self, h): """outputInfo call not expected.""" try: LOG.debug3('outputInfo() called, ignoring {}'.format(h)) except Exception: # pylint: disable=broad-except LOG.exception("outputInfo") return OutputHandler.REPORT def outputMessage(self, h): """outputMessage call not expected, indicates an error.""" try: LOG.debug3('outputMessage() called, ignoring {}'.format(h)) except Exception: # pylint: disable=broad-except LOG.exception("outputMessage") return OutputHandler.REPORT def _chmod_644_minimum(self, sha1): """Ensure blob file mode is correct. pygit2 created a blob. If that blob is a loose object, make sure that loose object's file has at least file mode 644 so that we (owner) has read+write, and the world has read access. Don't raise/abort if this fails due to file not found. Assume that is due to the blob landing in a packfile. """ obj_path = p4gf_git.object_path(sha1) if obj_path is None: # Object is already in the repo in a pack file? Nothing # more do be done here. if LOG.isEnabledFor(logging.DEBUG2): LOG.debug2("_chmod_644_minimum() no such loose blob %s, nothing to do", sha1) return blob_path = os.path.join(self.ctx.repo_dirs.GIT_WORK_TREE, obj_path) try: p4gf_util.chmod_644_minimum(blob_path) except OSError as e: LOG.warning("chmod 644 failed path={path} err={e}".format(path=blob_path, e=e))