parser.add_option("-f", "--force", action="store_true",

help="Force creation of merges")

parser.add_option("-D", "--source-distro", type="string", metavar="DISTRO",

default=None,

help="Source distribution")

parser.add_option("-S", "--source-suite", type="string", metavar="SUITE",

default=None,

help="Source suite (aka distrorelease)")

parser.add_option("-t", "--target", type="string", metavar="TARGET",

default=None,

help="Distribution target to use")

parser.add_option("-V", "--version", type="string", metavar="VER",

help="Version to obtain from destination")

parser.add_option("-X", "--exclude", type="string", metavar="FILENAME",

action="append",

help="Exclude packages listed in this file")

parser.add_option("-I", "--include", type="string", metavar="FILENAME",

action="append",

update_info = UpdateInfo(pkg)

if update_info.version is None:

logger.error('UpdateInfo version %s does not match our version %s"',

update_info.version, our_version)

report = MergeReport(left=our_version)

report.target = target.name

report.result = MergeResult.FAILED

report.message = 'Could not find update info for version %s' % our_version

return report

if update_info.upstream_version is None \

or our_version.version >= update_info.upstream_version:

logger.debug("No updated upstream version available for %s", our_version)

cleanup(output_dir)

report = MergeReport(left=our_version)

report.target = target.name

report.result = MergeResult.KEEP_OURS

report.merged_version = our_version.version

return report

if update_info.base_version is None:

logger.info("No base version available for %s", our_version)

cleanup(output_dir)

report = MergeReport(left=our_version)

report.target = target.name

report.result = MergeResult.NO_BASE

return report

upstream = None

base = None

pool_versions = target.getAllPoolVersions(pkg.name)

for pv in pool_versions:

if pv.version == update_info.upstream_version:

upstream = pv

if pv.version == update_info.base_version:

base = pv

if upstream is None:

logger.error('Could not find upstream version %s in pool',

update_info.upstream_version)

cleanup(output_dir)

report = MergeReport(left=our_version)

report.target = target.name

report.result = MergeResult.FAILED

report.message = 'Could not find upstream version %s in pool' \

% update_info.upstream_version

return report

if base is None:

logger.error('Could not find base version %s in pool',

update_info.base_version)

cleanup(output_dir)

report = MergeReport(left=our_version)

report.target = target.name

report.result = MergeResult.FAILED

report.message = 'Could not find base version %s in pool' \

% update_info.base_version

return report

try:

report = read_report(output_dir)

# See if sync_upstream_packages already set

if not options.force and \

pkg.name in target.sync_upstream_packages and \

Version(report['right_version']) == upstream.version and \

Version(report['left_version']) == our_version.version and \

Version(report['merged_version']) == upstream.version and \

report['result'] == MergeResult.SYNC_THEIRS:

logger.info("sync to upstream for %s [ours=%s, theirs=%s] "

"already produced, skipping run", pkg,

our_version.version, upstream.version)

return None

elif (not options.force and

Version(report['right_version']) == upstream.version and

Version(report['left_version']) == our_version.version and

# we'll retry the merge if there was an unexpected

# failure, a missing base or an unknown result last time

report['result'] in (MergeResult.KEEP_OURS,

MergeResult.SYNC_THEIRS, MergeResult.MERGED,

MergeResult.CONFLICTS)):

logger.info("merge for %s [ours=%s, theirs=%s] already produced, skipping run", pkg, our_version.version, upstream.version)

return None

except (AttributeError, ValueError, KeyError):

pass

if pkg.name in target.sync_upstream_packages:

logger.info("Syncing to %s per sync_upstream_packages", upstream)

cleanup(output_dir)

report = MergeReport(left=our_version, right=upstream)

report.target = target.name

report.result = MergeResult.SYNC_THEIRS

report.merged_version = upstream.version

report.message = "Using version in upstream distro per " \

"sync_upstream_packages configuration"

return report

logger.info("local: %s, upstream: %s", our_version, upstream)

try:

return produce_merge(target, base, our_version, upstream, output_dir)

except ValueError as e:

logger.exception("Could not produce merge, perhaps %s changed components upstream?", pkg)

report = MergeReport(left=our_version, right=upstream)

report.target = target.name

report.result = MergeResult.FAILED

report.message = 'Could not produce merge: %s' % e

logger.info('Producing merges...')

excludes = []

if options.exclude is not None:

for filename in options.exclude:

logger.info('excluding packages from %s', filename)

excludes.extend(read_package_list(filename))

includes = []

if options.include is not None:

for filename in options.include:

logger.info('including packages from %s', filename)

includes.extend(read_package_list(filename))

# For each package in the destination distribution, locate the latest in

# the source distribution; calculate the base from the destination and

# produce a merge combining both sets of changes

for target in config.targets(args):

logger.info('considering target %s', target)

our_dist = target.dist

our_component = target.component

d = target.distro

for pkg in d.packages(target.dist, target.component):

if options.package is not None and pkg.name not in options.package:

continue

if len(includes) and pkg.name not in includes:

logger.info('skipping package %s: not in include list', pkg.name)

continue

if len(excludes) and pkg.name in excludes:

logger.info('skipping package %s: in exclude list', pkg.name)

continue

if pkg.name in target.blacklist:

logger.info("%s is blacklisted, skipping", pkg.name)

continue

logger.info('considering package %s', pkg.name)

if options.version:

our_version = PackageVersion(pkg, Version(options.version))

logger.debug('our version: %s (from command line)', our_version)

else:

our_version = pkg.newestVersion()

logger.debug('our version: %s', our_version)

output_dir = result_dir(target.name, pkg.name)

try:

report = handle_package(output_dir, target, pkg, our_version)

if report is not None:

report.write_report(output_dir)

except Exception:

"""Return true if the two sources have different build-time metadata."""

for field in ["Binary", "Architecture", "Build-Depends", "Build-Depends-Indep", "Build-Conflicts", "Build-Conflicts-Indep"]:

if field in left_source and field not in right_source:

return True

if field not in left_source and field in right_source:

return True

if field in left_source and field in right_source and left_source[field] != right_source[field]:

return True

def __init__(self):

### Changes made relative to the right version

self.added_files = set()

self.removed_files = set()

self.modified_files = set()

### Unsolved problems

# Files that generated conflicts when merging

self.conflicts = set()

@property

def total_modifications(self):

"""Total number of modifications made relative to the right version"""

return len(self.added_files) + len(self.removed_files) + \

right_dir, right_name, right_format, right_distro, merged_dir):

"""Do the heavy lifting of comparing and merging."""

logger.debug("Producing merge in %s", merged_dir)

result = MergeData()

po_files = []

both_formats_quilt = left_format == right_format == "3.0 (quilt)"

if both_formats_quilt:

logger.debug("Only merging debian directory since both "

"formats 3.0 (quilt)")

# Look for files in the base and merge them if they're in both new

# files (removed files get removed)

for filename in tree.walk(base_dir):

# If both packages are 3.0 (quilt), ignore everything except the

# debian directory

if both_formats_quilt and not tree.under("debian", filename):

continue

if tree.under(".pc", filename):

# Not interested in merging quilt metadata

continue

base_stat = os.lstat("%s/%s" % (base_dir, filename))

try:

left_stat = os.lstat("%s/%s" % (left_dir, filename))

except OSError:

left_stat = None

try:

right_stat = os.lstat("%s/%s" % (right_dir, filename))

except OSError:

right_stat = None

if left_stat is None and right_stat is None:

# Removed on both sides

pass

elif left_stat is None:

logger.debug("removed from %s: %s", left_distro, filename)

if not same_file(base_stat, base_dir, right_stat, right_dir,

filename):

# Changed on RHS

result.conflicts.add(filename)

else:

result.removed_files.add(filename)

elif right_stat is None:

# Removed on RHS only

logger.debug("removed from %s: %s", right_distro, filename)

if not same_file(base_stat, base_dir, left_stat, left_dir,

filename):

# Changed on LHS

result.conflicts.add(filename)

elif S_ISREG(left_stat.st_mode) and S_ISREG(right_stat.st_mode):

# Common case: left and right are both files

handle_file(left_stat, left_dir, left_name, left_distro,

right_dir, right_stat, right_name, right_distro,

base_stat, base_dir,

merged_dir, filename, po_files, result)

elif same_file(left_stat, left_dir, right_stat, right_dir, filename):

# left and right are the same, doesn't matter which we keep

tree.copyfile("%s/%s" % (right_dir, filename),

"%s/%s" % (merged_dir, filename))

elif same_file(base_stat, base_dir, left_stat, left_dir, filename):

# right has changed in some way, keep that one

logger.debug("preserving non-file change in %s: %s",

right_distro, filename)

tree.copyfile("%s/%s" % (right_dir, filename),

"%s/%s" % (merged_dir, filename))

elif same_file(base_stat, base_dir, right_stat, right_dir, filename):

# left has changed in some way, keep that one

logger.debug("preserving non-file change in %s: %s",

left_distro, filename)

tree.copyfile("%s/%s" % (left_dir, filename),

"%s/%s" % (merged_dir, filename))

result.modified_files.add(filename)

else:

# all three differ, mark a conflict

result.conflicts.add(filename)

# Look for files in the left hand side that aren't in the base,

# conflict if new on both sides or copy into the tree

for filename in tree.walk(left_dir):

# If both packages are 3.0 (quilt), ignore everything except the

# debian directory

if both_formats_quilt and not tree.under("debian", filename):

continue

if tree.under(".pc", filename):

# Not interested in merging quilt metadata

continue

if tree.exists("%s/%s" % (base_dir, filename)):

continue

if not tree.exists("%s/%s" % (right_dir, filename)):

logger.debug("new in %s: %s", left_distro, filename)

tree.copyfile("%s/%s" % (left_dir, filename),

"%s/%s" % (merged_dir, filename))

result.added_files.add(filename)

continue

left_stat = os.lstat("%s/%s" % (left_dir, filename))

right_stat = os.lstat("%s/%s" % (right_dir, filename))

if S_ISREG(left_stat.st_mode) and S_ISREG(right_stat.st_mode):

# Common case: left and right are both files

handle_file(left_stat, left_dir, left_name, left_distro,

right_dir, right_stat, right_name, right_distro,

None, None, merged_dir, filename,

po_files, result)

elif same_file(left_stat, left_dir, right_stat, right_dir, filename):

# left and right are the same, doesn't matter which we keep

tree.copyfile("%s/%s" % (right_dir, filename),

"%s/%s" % (merged_dir, filename))

else:

# they differ, mark a conflict

result.conflicts.add(filename)

# Copy new files on the right hand side only into the tree

for filename in tree.walk(right_dir):

if tree.under(".pc", filename):

# Not interested in merging quilt metadata

continue

if both_formats_quilt and not tree.under("debian", filename):

# Always copy right version for quilt non-debian files

if not tree.exists("%s/%s" % (left_dir, filename)):

logger.debug("new in %s: %s", right_distro, filename)

else:

if tree.exists("%s/%s" % (base_dir, filename)):

continue

if tree.exists("%s/%s" % (left_dir, filename)):

continue

logger.debug("new in %s: %s", right_distro, filename)

tree.copyfile("%s/%s" % (right_dir, filename),

"%s/%s" % (merged_dir, filename))

# Handle po files separately as they need special merging

for filename in po_files:

if not merge_po(left_dir, right_dir, merged_dir, filename):

result.conflicts.add(filename)

continue

merge_attr(base_dir, left_dir, right_dir, merged_dir, filename, result)

result.modified_files.add(filename)

for conflict in result.conflicts:

conflict_file(left_dir, left_distro, right_dir, right_distro,

merged_dir, conflict)

right_dir, right_stat, right_name, right_distro,

base_stat, base_dir, merged_dir, filename, po_files):

if filename == "debian/changelog":

# two-way merge of changelogs

try:

merge_changelog(left_dir, right_dir, merged_dir, filename)

return False, False

except:

return True, False

elif filename.endswith(".po"):

# two-way merge of po contents (do later)

po_files.append(filename)

return False, True

elif filename.endswith(".pot"):

# two-way merge of pot contents

ret = merge_pot(left_dir, right_dir, merged_dir, filename)

return not ret, False

elif base_stat is not None and S_ISREG(base_stat.st_mode):

# was file in base: diff3 possible

ret = diff3_merge(left_dir, left_name, left_distro, base_dir,

right_dir, right_name, right_distro, merged_dir,

filename)

return not ret, False

else:

# general file conflict

right_dir, right_stat, right_name, right_distro,

base_stat, base_dir, merged_dir, filename, po_files, result):

"""Handle the common case of a file in both left and right."""

do_attrs = True

if base_stat and \

same_file(base_stat, base_dir, left_stat, left_dir, filename):

# same file contents in base and left, meaning that the left

# side was unmodified, so take the right side as-is

logger.debug("%s was unmodified on the left", filename)

tree.copyfile("%s/%s" % (right_dir, filename),

"%s/%s" % (merged_dir, filename))

elif same_file(left_stat, left_dir, right_stat, right_dir, filename):

# same file contents in left and right

logger.debug("%s and %s both turned into same file: %s",

left_distro, right_distro, filename)

tree.copyfile("%s/%s" % (left_dir, filename),

"%s/%s" % (merged_dir, filename))

else:

conflicts, deferred = \

merge_file_contents(left_stat, left_dir, left_name, left_distro,

right_dir, right_stat, right_name,

right_distro, base_stat, base_dir,

merged_dir, filename, po_files)

if conflicts:

result.conflicts.add(filename)

do_attrs = False

if deferred:

do_attrs = False

else:

result.modified_files.add(filename)

# Merge file permissions

if do_attrs:

"""Are two filesystem objects the same?"""

if S_IFMT(left_stat.st_mode) != S_IFMT(right_stat.st_mode):

# Different fundamental types

return False

elif S_ISREG(left_stat.st_mode):

# Files with the same size and MD5sum are the same

if left_stat.st_size != right_stat.st_size:

return False

elif md5sum("%s/%s" % (left_dir, filename)) \

!= md5sum("%s/%s" % (right_dir, filename)):

return False

else:

return True

elif S_ISDIR(left_stat.st_mode) or S_ISFIFO(left_stat.st_mode) \

or S_ISSOCK(left_stat.st_mode):

# Directories, fifos and sockets are always the same

return True

elif S_ISCHR(left_stat.st_mode) or S_ISBLK(left_stat.st_mode):

# Char/block devices are the same if they have the same rdev

if left_stat.st_rdev != right_stat.st_rdev:

return False

else:

return True

elif S_ISLNK(left_stat.st_mode):

# Symbolic links are the same if they have the same target

if os.readlink("%s/%s" % (left_dir, filename)) \

!= os.readlink("%s/%s" % (right_dir, filename)):

return False

else:

return True

else:

"""Merge a changelog file."""

logger.debug("Knitting %s", filename)

left_cl = read_changelog("%s/%s" % (left_dir, filename))

right_cl = read_changelog("%s/%s" % (right_dir, filename))

tree.ensure(filename)

with open("%s/%s" % (merged_dir, filename), "w") as output:

for right_ver, right_text in right_cl:

while len(left_cl) and left_cl[0][0] > right_ver:

(left_ver, left_text) = left_cl.pop(0)

print >>output, left_text

while len(left_cl) and left_cl[0][0] == right_ver:

(left_ver, left_text) = left_cl.pop(0)

print >>output, right_text

for left_ver, left_text in left_cl:

print >>output, left_text

"""Update a .po file using msgcat or msgmerge."""

merged_po = "%s/%s" % (merged_dir, filename)

closest_pot = find_closest_pot(merged_po)

if closest_pot is None:

return merge_pot(left_dir, right_dir, merged_dir, filename)

left_po = "%s/%s" % (left_dir, filename)

right_po = "%s/%s" % (right_dir, filename)

logger.debug("Merging PO file %s", filename)

try:

tree.ensure(merged_po)

shell.run(("msgmerge", "--force-po", "-o", merged_po,

"-C", left_po, right_po, closest_pot))

except (ValueError, OSError):

logger.error("PO file merge failed: %s", filename)

return False

"""Update a .po file using msgcat."""

merged_pot = "%s/%s" % (merged_dir, filename)

left_pot = "%s/%s" % (left_dir, filename)

right_pot = "%s/%s" % (right_dir, filename)

logger.debug("Merging POT file %s", filename)

try:

tree.ensure(merged_pot)

shell.run(("msgcat", "--force-po", "--use-first", "-o", merged_pot,

right_pot, left_pot))

except (ValueError, OSError):

logger.error("POT file merge failed: %s", filename)

return False

"""Find the closest .pot file to the po file given."""

dirname = os.path.dirname(po_file)

for entry in os.listdir(dirname):

if entry.endswith(".pot"):

return os.path.join(dirname, entry)

else:

right_dir, right_name, right_distro, merged_dir, filename):

"""Merge a file using diff3."""

dest = "%s/%s" % (merged_dir, filename)

tree.ensure(dest)

with open(dest, "w") as output:

status = shell.run(("diff3", "-E", "-m",

"-L", left_name, "%s/%s" % (left_dir, filename),

"-L", "BASE", "%s/%s" % (base_dir, filename),

"-L", right_name, "%s/%s" % (right_dir, filename)),

stdout=output, okstatus=(0,1,2))

if status != 0:

if not tree.exists(dest) or os.stat(dest).st_size == 0:

# Probably binary

if same_file(os.stat("%s/%s" % (left_dir, filename)), left_dir,

os.stat("%s/%s" % (right_dir, filename)), right_dir,

filename):

logger.debug("binary files are the same: %s", filename)

tree.copyfile("%s/%s" % (left_dir, filename),

"%s/%s" % (merged_dir, filename))

elif same_file(os.stat("%s/%s" % (base_dir, filename)), base_dir,

os.stat("%s/%s" % (left_dir, filename)), left_dir,

filename):

logger.debug("preserving binary change in %s: %s",

right_distro, filename)

tree.copyfile("%s/%s" % (right_dir, filename),

"%s/%s" % (merged_dir, filename))

elif same_file(os.stat("%s/%s" % (base_dir, filename)), base_dir,

os.stat("%s/%s" % (right_dir, filename)), right_dir,

filename):

logger.debug("preserving binary change in %s: %s",

left_distro, filename)

tree.copyfile("%s/%s" % (left_dir, filename),

"%s/%s" % (merged_dir, filename))

else:

logger.debug("binary file conflict: %s", filename)

return False

else:

logger.debug("Conflict in %s", filename)

return False

else:

"""Set initial and merge changed attributes."""

if base_dir is not None \

and os.path.isfile("%s/%s" % (base_dir, filename)) \

and not os.path.islink("%s/%s" % (base_dir, filename)):

set_attr(base_dir, merged_dir, filename)

apply_attr(base_dir, left_dir, merged_dir, filename, result)

apply_attr(base_dir, right_dir, merged_dir, filename, result)

else:

set_attr(right_dir, merged_dir, filename)

"""Apply attribute changes from one side to a file."""

src_stat = os.stat("%s/%s" % (src_dir, filename))

base_stat = os.stat("%s/%s" % (base_dir, filename))

changed = False

for shift in range(0, 9):

bit = 1 << shift

# Permission bit added

if not base_stat.st_mode & bit and src_stat.st_mode & bit:

change_attr(dest_dir, filename, bit, shift, True)

changed = True

# Permission bit removed

if base_stat.st_mode & bit and not src_stat.st_mode & bit:

change_attr(dest_dir, filename, bit, shift, False)

changed = True

if changed:

"""Apply a single attribute change."""

logger.debug("Setting %s %s", filename,

[ "u+r", "u+w", "u+x", "g+r", "g+w", "g+x",

"o+r", "o+w", "o+x" ][shift])

dest = "%s/%s" % (dest_dir, filename)

attr = os.stat(dest).st_mode & 0777

if add:

attr |= bit

else:

attr &= ~bit

dest_dir, filename):

"""Copy both files as conflicts of each other."""

left_src = "%s/%s" % (left_dir, filename)

right_src = "%s/%s" % (right_dir, filename)

dest = "%s/%s" % (dest_dir, filename)

logger.debug("Conflicted: %s", filename)

tree.remove(dest)

# We need to take care here .. if one of the items involved in a

# conflict is a directory then it might have children and we don't want

# to throw an error later.

#

# We get round this by making the directory a symlink to the conflicted

# one.

#

# Fortunately this is so rare it may never happen!

if tree.exists(left_src):

tree.copyfile(left_src, "%s.%s" % (dest, left_distro.upper()))

if os.path.isdir(left_src):

os.symlink("%s.%s" % (os.path.basename(dest), left_distro.upper()),

dest)

if tree.exists(right_src):

tree.copyfile(right_src, "%s.%s" % (dest, right_distro.upper()))

if os.path.isdir(right_src):

os.symlink("%s.%s" % (os.path.basename(dest), right_distro.upper()),

right_distro, right_dist, merged_dir):

"""Add a changelog entry to the package."""

changelog_file = "%s/debian/changelog" % merged_dir

with open(changelog_file) as changelog:

with open(changelog_file + ".new", "w") as new_changelog:

print >>new_changelog, ("%s (%s) UNRELEASED; urgency=low"

% (package, merged_version))

print >>new_changelog

print >>new_changelog, " * Merge from %s %s." \

% (right_distro.title(), right_dist)

print >>new_changelog

print >>new_changelog, (" -- %s <%s> " % (config.get('MOM_NAME'),

config.get('MOM_EMAIL')) +

time.strftime("%a, %d %b %Y %H:%M:%S %z"))

print >>new_changelog

for line in changelog:

print >>new_changelog, line.rstrip("\r\n")

"""Make a copy of the source files."""

pkg = pkgver.package

for md5sum, size, name in files(pkgver.getDscContents()):

src = "%s/%s" % (pkg.poolPath, name)

dest = "%s/%s" % (output_dir, name)

if os.path.isfile(dest):

os.unlink(dest)

try:

logger.debug("%s -> %s", src, dest)

os.link(src, dest)

except OSError, e:

logger.exception("File not found: %s", src)

patch = patch_file(pkg.distro, pkgver)

if os.path.isfile(patch):

output = "%s/%s" % (output_dir, os.path.basename(patch))

if not os.path.exists(output):

os.link(patch, output)

return os.path.basename(patch)

else:

"""Create a tarball of a merge with conflicts."""

filename = "%s/%s_%s.src.tar.gz" % (output_dir, package,

version.without_epoch)

contained = "%s-%s" % (package, version.without_epoch)

tree.ensure("%s/tmp/" % config.get('ROOT'))

parent = tempfile.mkdtemp(dir="%s/tmp/" % config.get('ROOT'))

try:

tree.copytree(merged_dir, "%s/%s" % (parent, contained))

debian_rules = "%s/%s/debian/rules" % (parent, contained)

if os.path.isfile(debian_rules):

os.chmod(debian_rules, os.stat(debian_rules).st_mode | 0111)

shell.run(("tar", "czf", filename, contained), chdir=parent)

logger.info("Created %s", tree.subdir(config.get('ROOT'), filename))

return os.path.basename(filename)

finally:

"""Create a source package without conflicts."""

contained = "%s-%s" % (package, version.upstream)

dsc_filename = "%s_%s.dsc" % (package, version.without_epoch)

tree.ensure("%s/tmp/" % config.get('ROOT'))

parent = tempfile.mkdtemp(dir="%s/tmp/" % config.get('ROOT'))

try:

tree.copytree(merged_dir, "%s/%s" % (parent, contained))

match = '%s_%s.orig(-\w+)?.tar.(gz|bz2|xz)$' \

% (re.escape(package), re.escape(version.upstream))

for filename in os.listdir(output_dir):

if re.match(match, filename) is None:

continue

path = os.path.join(output_dir, filename)

if os.path.isfile(path):

os.link(path,

"%s/%s" % (parent, filename))

cmd = ("dpkg-source",)

if version.revision is not None and since.upstream != version.upstream:

cmd += ("-sa",)

cmd += ("-b", contained)

try:

dpkg_source_output = subprocess.check_output(cmd, cwd=parent,

stderr=subprocess.STDOUT)

except subprocess.CalledProcessError, e:

logger.warning("dpkg-source failed with code %d:\n%s\n",

e.returncode, e.output)

# for the message in the JSON report, just take the last line

# and hope it's relevant...

lastline = re.sub(r'.*\n', '', e.output.rstrip('\n'),

flags=re.DOTALL)

return (MergeResult.FAILED,

"unable to build merged source package: "

"dpkg-source failed with %d (%s)" % (

e.returncode, lastline),

create_tarball(package, version, output_dir, merged_dir))

else:

logger.debug("dpkg-source succeeded:\n%s\n", dpkg_source_output)

if os.path.isfile("%s/%s" % (parent, dsc_filename)):

logger.info("Created dpkg-source %s", dsc_filename)

for name in os.listdir(parent):

src = "%s/%s" % (parent, name)

dest = "%s/%s" % (output_dir, name)

if os.path.isfile(src) and not os.path.isfile(dest):

os.link(src, dest)

return (MergeResult.MERGED, None, os.path.basename(dsc_filename))

else:

message = ("dpkg-source did not produce expected filename %s" %

tree.subdir(config.get('ROOT'), dsc_filename))

logger.warning("%s", message)

return (MergeResult.FAILED,

"unable to build merged source package (%s)" % message,

create_tarball(package, version, output_dir, merged_dir))

finally:

"""Create the merged patch."""

parent = tempfile.mkdtemp()

try:

tree.copytree(merged_dir, "%s/%s" % (parent, version))

tree.copytree(basis_dir, "%s/%s" % (parent, basis.version))

with open(filename, "w") as diff:

shell.run(("diff", "-pruN",

str(basis.version), str(version)),

chdir=parent, stdout=diff, okstatus=(0, 1, 2))

logger.info("Created %s", tree.subdir(config.get('ROOT'), filename))

return os.path.basename(filename)

finally:

"""Read a list of packages from the given file."""

packages = []

with open(filename) as list_file:

for line in list_file:

if line.startswith("#"):

continue

package = line.strip()

if len(package):

packages.append(package)

fh = None

name = None

n = 0

for (v, text) in cl_versions:

n += 1

if v in bases:

break

if limit is not None and n > limit:

break

if fh is None:

name = '%s_changelog.txt' % pv.version

path = '%s/%s' % (output_dir, name)

tree.ensure(path)

fh = open(path, 'w')

fh.write(text + '\n')

if fh is not None:

fh.close()

left_dir = unpack_source(left)

upstream_dir = unpack_source(upstream)

base_dir = unpack_source(base)

report = MergeReport(left=left, right=upstream)

report.target = target.name

report.mom_version = str(VERSION)

report.merge_date = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())

cleanup(output_dir)

downstream_versions = read_changelog(left_dir + '/debian/changelog')

upstream_versions = read_changelog(upstream_dir + '/debian/changelog')

report.left_changelog = save_changelog(output_dir, downstream_versions,

left, [base.version])

# If the base is a common ancestor, log everything from the ancestor

# to the current version. Otherwise just log the first entry.

limit = 1

for upstream_version, text in upstream_versions:

if upstream_version == base.version:

limit = None

break

report.right_changelog = save_changelog(output_dir, upstream_versions,

upstream, [base.version], limit)

report.set_base(base)

logger.info('base version: %s', base.version)

generate_patch(base, left.package.distro, left, slipped=False, force=False,

unpacked=True)

generate_patch(base, upstream.package.distro, upstream, slipped=False,

force=False, unpacked=True)

report.merged_version = Version(str(upstream.version)+config.get('LOCAL_SUFFIX')+'1')

if base >= upstream:

logger.info("Nothing to be done: %s >= %s", base, upstream)

report.result = MergeResult.KEEP_OURS

report.merged_version = left.version

report.write_report(output_dir)

return report

# Careful: MergeReport.merged_dir is the output directory for the .dsc or

# tarball, whereas our local variable merged_dir (below) is a temporary

# directory containing unpacked source code. Don't mix them up.

report.merged_dir = output_dir

if base.version == left.version:

logger.info("Syncing %s to %s", left, upstream)

if not os.path.isdir(output_dir):

os.makedirs(output_dir)

report.result = MergeResult.SYNC_THEIRS

report.build_metadata_changed = False

report.right_patch = copy_in(output_dir, upstream)

report.merged_version = upstream.version

report.merged_patch = report.right_patch

report.merged_files = report.right_files

write_report(report,

left=left,

base=base,

right=upstream,

src_file=None,

# this is MergeReport.merged_dir...