From 395ef28947528cc4cd955ae4480c2b6b5561c892 Mon Sep 17 00:00:00 2001 From: Philipp Zabel Date: Mon, 28 Aug 2006 19:29:30 +0000 Subject: rm_work.bbclass: stop cleaning out before populate_staging --- classes/rm_work.bbclass | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'classes') diff --git a/classes/rm_work.bbclass b/classes/rm_work.bbclass index 340446917e..7f590e1b15 100644 --- a/classes/rm_work.bbclass +++ b/classes/rm_work.bbclass @@ -19,4 +19,4 @@ do_rm_work () { } addtask rm_work before do_build -addtask rm_work after do_package +addtask rm_work after do_populate_staging -- cgit v1.2.3 From d3c0ca658f75bf8f2aa96c51126712eb8d45c875 Mon Sep 17 00:00:00 2001 From: Chris Larson Date: Mon, 28 Aug 2006 20:30:14 +0000 Subject: Merge from poky: Rework the way patches are handled. There are now two abstract base classes, initialized in patch.bbclass. One for patchset operations on a directory, and another for patch failure resolution. Currently includes 'patch' and 'quilt' concrete PatchSet classes, and a 'user' resolver class, which simply drops you into a shell in the source tree to fix the rejects. --- classes/base.bbclass | 96 ++-------- classes/patch.bbclass | 476 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 487 insertions(+), 85 deletions(-) create mode 100644 classes/patch.bbclass (limited to 'classes') diff --git a/classes/base.bbclass b/classes/base.bbclass index 670b97a72d..51b6d2111f 100644 --- a/classes/base.bbclass +++ b/classes/base.bbclass @@ -1,5 +1,4 @@ BB_DEFAULT_TASK = "build" -PATCHES_DIR="${S}" def base_dep_prepend(d): import bb; @@ -13,9 +12,11 @@ def base_dep_prepend(d): # INHIBIT_DEFAULT_DEPS doesn't apply to the patch command. Whether or not # we need that built is the responsibility of the patch function / class, not # the application. - patchdeps = bb.data.getVar("PATCH_DEPENDS", d, 1) - if patchdeps and not patchdeps in bb.data.getVar("PROVIDES", d, 1): - deps = patchdeps + patchdeps = bb.data.getVar("PATCHTOOL", d, 1) + if patchdeps: + patchdeps = "%s-native" % patchdeps + if not patchdeps in bb.data.getVar("PROVIDES", d, 1): + deps = patchdeps if not bb.data.getVar('INHIBIT_DEFAULT_DEPS', d): if (bb.data.getVar('HOST_SYS', d, 1) != @@ -451,86 +452,6 @@ python base_do_unpack() { raise bb.build.FuncFailed() } -addtask patch after do_unpack -do_patch[dirs] = "${WORKDIR}" -python base_do_patch() { - import re - import bb.fetch - - src_uri = (bb.data.getVar('SRC_URI', d, 1) or '').split() - if not src_uri: - return - - patchcleancmd = bb.data.getVar('PATCHCLEANCMD', d, 1) - if patchcleancmd: - bb.data.setVar("do_patchcleancmd", patchcleancmd, d) - bb.data.setVarFlag("do_patchcleancmd", "func", 1, d) - bb.build.exec_func("do_patchcleancmd", d) - - workdir = bb.data.getVar('WORKDIR', d, 1) - for url in src_uri: - - (type, host, path, user, pswd, parm) = bb.decodeurl(url) - if not "patch" in parm: - continue - - bb.fetch.init([url],d) - url = bb.encodeurl((type, host, path, user, pswd, [])) - local = os.path.join('/', bb.fetch.localpath(url, d)) - - # did it need to be unpacked? - dots = os.path.basename(local).split(".") - if dots[-1] in ['gz', 'bz2', 'Z']: - unpacked = os.path.join(bb.data.getVar('WORKDIR', d),'.'.join(dots[0:-1])) - else: - unpacked = local - unpacked = bb.data.expand(unpacked, d) - - if "pnum" in parm: - pnum = parm["pnum"] - else: - pnum = "1" - - if "pname" in parm: - pname = parm["pname"] - else: - pname = os.path.basename(unpacked) - - if "mindate" in parm: - mindate = parm["mindate"] - else: - mindate = 0 - - if "maxdate" in parm: - maxdate = parm["maxdate"] - else: - maxdate = "20711226" - - pn = bb.data.getVar('PN', d, 1) - srcdate = bb.data.getVar('SRCDATE_%s' % pn, d, 1) - - if not srcdate: - srcdate = bb.data.getVar('SRCDATE', d, 1) - - if srcdate == "now": - srcdate = bb.data.getVar('DATE', d, 1) - - if (maxdate < srcdate) or (mindate > srcdate): - if (maxdate < srcdate): - bb.note("Patch '%s' is outdated" % pname) - - if (mindate > srcdate): - bb.note("Patch '%s' is predated" % pname) - - continue - - bb.note("Applying patch '%s'" % pname) - bb.data.setVar("do_patchcmd", bb.data.getVar("PATCHCMD", d, 1) % (pnum, pname, unpacked), d) - bb.data.setVarFlag("do_patchcmd", "func", 1, d) - bb.data.setVarFlag("do_patchcmd", "dirs", "${WORKDIR} ${S}", d) - bb.build.exec_func("do_patchcmd", d) -} - addhandler base_eventhandler python base_eventhandler() { @@ -615,6 +536,8 @@ base_do_compile() { fi } + +addtask stage after do_compile base_do_stage () { : } @@ -759,7 +682,10 @@ python () { return } -EXPORT_FUNCTIONS do_clean do_mrproper do_fetch do_unpack do_configure do_compile do_install do_package do_patch do_populate_pkgs do_stage +# Patch handling +inherit patch + +EXPORT_FUNCTIONS do_clean do_mrproper do_fetch do_unpack do_configure do_compile do_install do_package do_populate_pkgs do_stage MIRRORS[func] = "0" MIRRORS () { diff --git a/classes/patch.bbclass b/classes/patch.bbclass new file mode 100644 index 0000000000..ea0182484e --- /dev/null +++ b/classes/patch.bbclass @@ -0,0 +1,476 @@ +# Copyright (C) 2006 OpenedHand LTD + +def patch_init(d): + import os, sys + + def md5sum(fname): + import md5, sys + + f = file(fname, 'rb') + m = md5.new() + while True: + d = f.read(8096) + if not d: + break + m.update(d) + f.close() + return m.hexdigest() + + class CmdError(Exception): + def __init__(self, exitstatus, output): + self.status = exitstatus + self.output = output + + def __str__(self): + return "Command Error: exit status: %d Output:\n%s" % (self.status, self.output) + + class NotFoundError(Exception): + def __init__(self, path): + self.path = path + def __str__(self): + return "Error: %s not found." % self.path + + def runcmd(args, dir = None): + import commands + + if dir: + olddir = os.path.abspath(os.curdir) + if not os.path.exists(dir): + raise NotFoundError(dir) + os.chdir(dir) + # print("cwd: %s -> %s" % (olddir, self.dir)) + + try: + args = [ commands.mkarg(str(arg)) for arg in args ] + cmd = " ".join(args) + # print("cmd: %s" % cmd) + (exitstatus, output) = commands.getstatusoutput(cmd) + if exitstatus != 0: + raise CmdError(exitstatus >> 8, output) + return output + + finally: + if dir: + os.chdir(olddir) + + class PatchError(Exception): + def __init__(self, msg): + self.msg = msg + + def __str__(self): + return "Patch Error: %s" % self.msg + + import bb, bb.data, bb.fetch + + class PatchSet(object): + defaults = { + "strippath": 1 + } + + def __init__(self, dir, d): + self.dir = dir + self.d = d + self.patches = [] + self._current = None + + def current(self): + return self._current + + def Clean(self): + """ + Clean out the patch set. Generally includes unapplying all + patches and wiping out all associated metadata. + """ + raise NotImplementedError() + + def Import(self, patch, force): + if not patch.get("file"): + if not patch.get("remote"): + raise PatchError("Patch file must be specified in patch import.") + else: + patch["file"] = bb.fetch.localpath(patch["remote"], self.d) + + for param in PatchSet.defaults: + if not patch.get(param): + patch[param] = PatchSet.defaults[param] + + if patch.get("remote"): + patch["file"] = bb.data.expand(bb.fetch.localpath(patch["remote"], self.d), self.d) + + patch["filemd5"] = md5sum(patch["file"]) + + def Push(self, force): + raise NotImplementedError() + + def Pop(self, force): + raise NotImplementedError() + + def Refresh(self, remote = None, all = None): + raise NotImplementedError() + + + class PatchTree(PatchSet): + def __init__(self, dir, d): + PatchSet.__init__(self, dir, d) + + def Import(self, patch, force = None): + """""" + PatchSet.Import(self, patch, force) + + self.patches.insert(self._current or 0, patch) + + def _applypatch(self, patch, force = None, reverse = None): + shellcmd = ["patch", "<", patch['file'], "-p", patch['strippath']] + if reverse: + shellcmd.append('-R') + shellcmd.append('--dry-run') + + try: + output = runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) + except CmdError: + if force: + shellcmd.pop(len(shellcmd) - 1) + output = runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) + else: + import sys + raise sys.exc_value + + return output + + def Push(self, force = None, all = None): + if all: + for i in self.patches: + if self._current is not None: + self._current = self._current + 1 + else: + self._current = 0 + self._applypatch(i, force) + else: + if self._current is not None: + self._current = self._current + 1 + else: + self._current = 0 + self._applypatch(self.patches[self._current], force) + + + def Pop(self, force = None, all = None): + if all: + for i in self.patches: + self._applypatch(i, force, True) + else: + self._applypatch(self.patches[self._current], force, True) + + def Clean(self): + """""" + + class QuiltTree(PatchSet): + def _runcmd(self, args): + runcmd(["quilt"] + args, self.dir) + + def _quiltpatchpath(self, file): + return os.path.join(self.dir, "patches", os.path.basename(file)) + + + def __init__(self, dir, d): + PatchSet.__init__(self, dir, d) + self.initialized = False + + def Clean(self): + try: + self._runcmd(["pop", "-a", "-f"]) + except CmdError: + pass + except NotFoundError: + pass + # runcmd(["rm", "-rf", os.path.join(self.dir, "patches"), os.path.join(self.dir, ".pc")]) + self.initialized = True + + def InitFromDir(self): + # read series -> self.patches + seriespath = os.path.join(self.dir, 'patches', 'series') + if not os.path.exists(self.dir): + raise Exception("Error: %s does not exist." % self.dir) + if os.path.exists(seriespath): + series = file(seriespath, 'r') + for line in series.readlines(): + patch = {} + parts = line.strip().split() + patch["quiltfile"] = self._quiltpatchpath(parts[0]) + patch["quiltfilemd5"] = md5sum(patch["quiltfile"]) + if len(parts) > 1: + patch["strippath"] = parts[1][2:] + self.patches.append(patch) + series.close() + + # determine which patches are applied -> self._current + try: + output = runcmd(["quilt", "applied"], self.dir) + except CmdError: + if sys.exc_value.output.strip() == "No patches applied": + return + else: + raise sys.exc_value + output = [val for val in output.split('\n') if not val.startswith('#')] + for patch in self.patches: + if os.path.basename(patch["quiltfile"]) == output[-1]: + self._current = self.patches.index(patch) + self.initialized = True + + def Import(self, patch, force = None): + if not self.initialized: + self.InitFromDir() + PatchSet.Import(self, patch, force) + + args = ["import", "-p", patch["strippath"]] + if force: + args.append("-f") + args.append(patch["file"]) + + self._runcmd(args) + + patch["quiltfile"] = self._quiltpatchpath(patch["file"]) + patch["quiltfilemd5"] = md5sum(patch["quiltfile"]) + + # TODO: determine if the file being imported: + # 1) is already imported, and is the same + # 2) is already imported, but differs + + self.patches.insert(self._current or 0, patch) + + + def Push(self, force = None, all = None): + # quilt push [-f] + + args = ["push"] + if force: + args.append("-f") + if all: + args.append("-a") + + self._runcmd(args) + + if self._current is not None: + self._current = self._current + 1 + else: + self._current = 0 + + def Pop(self, force = None, all = None): + # quilt pop [-f] + args = ["pop"] + if force: + args.append("-f") + if all: + args.append("-a") + + self._runcmd(args) + + if self._current == 0: + self._current = None + + if self._current is not None: + self._current = self._current - 1 + + def Refresh(self, **kwargs): + if kwargs.get("remote"): + patch = self.patches[kwargs["patch"]] + if not patch: + raise PatchError("No patch found at index %s in patchset." % kwargs["patch"]) + (type, host, path, user, pswd, parm) = bb.decodeurl(patch["remote"]) + if type == "file": + import shutil + if not patch.get("file") and patch.get("remote"): + patch["file"] = bb.fetch.localpath(patch["remote"], self.d) + + shutil.copyfile(patch["quiltfile"], patch["file"]) + else: + raise PatchError("Unable to do a remote refresh of %s, unsupported remote url scheme %s." % (os.path.basename(patch["quiltfile"]), type)) + else: + # quilt refresh + args = ["refresh"] + if kwargs.get("quiltfile"): + args.append(os.path.basename(kwargs["quiltfile"])) + elif kwargs.get("patch"): + args.append(os.path.basename(self.patches[kwargs["patch"]]["quiltfile"])) + self._runcmd(args) + + class Resolver(object): + def __init__(self, patchset): + raise NotImplementedError() + + def Resolve(self): + raise NotImplementedError() + + def Revert(self): + raise NotImplementedError() + + def Finalize(self): + raise NotImplementedError() + + # Patch resolver which relies on the user doing all the work involved in the + # resolution, with the exception of refreshing the remote copy of the patch + # files (the urls). + class UserResolver(Resolver): + def __init__(self, patchset): + self.patchset = patchset + + # Force a push in the patchset, then drop to a shell for the user to + # resolve any rejected hunks + def Resolve(self): + + olddir = os.path.abspath(os.curdir) + os.chdir(self.patchset.dir) + try: + self.patchset.Push(True) + except CmdError, v: + # Patch application failed + if sys.exc_value.output.strip() == "No patches applied": + return + print(sys.exc_value) + print('NOTE: dropping user into a shell, so that patch rejects can be fixed manually.') + + os.system('/bin/sh') + + # Construct a new PatchSet after the user's changes, compare the + # sets, checking patches for modifications, and doing a remote + # refresh on each. + oldpatchset = self.patchset + self.patchset = oldpatchset.__class__(self.patchset.dir, self.patchset.d) + + for patch in self.patchset.patches: + oldpatch = None + for opatch in oldpatchset.patches: + if opatch["quiltfile"] == patch["quiltfile"]: + oldpatch = opatch + + if oldpatch: + patch["remote"] = oldpatch["remote"] + if patch["quiltfile"] == oldpatch["quiltfile"]: + if patch["quiltfilemd5"] != oldpatch["quiltfilemd5"]: + bb.note("Patch %s has changed, updating remote url %s" % (os.path.basename(patch["quiltfile"]), patch["remote"])) + # user change? remote refresh + self.patchset.Refresh(remote=True, patch=self.patchset.patches.index(patch)) + else: + # User did not fix the problem. Abort. + raise PatchError("Patch application failed, and user did not fix and refresh the patch.") + except Exception: + os.chdir(olddir) + raise + os.chdir(olddir) + + # Throw away the changes to the patches in the patchset made by resolve() + def Revert(self): + raise NotImplementedError() + + # Apply the changes to the patches in the patchset made by resolve() + def Finalize(self): + raise NotImplementedError() + + g = globals() + g["PatchSet"] = PatchSet + g["PatchTree"] = PatchTree + g["QuiltTree"] = QuiltTree + g["Resolver"] = Resolver + g["UserResolver"] = UserResolver + g["NotFoundError"] = NotFoundError + g["CmdError"] = CmdError + +addtask patch after do_unpack +do_patch[dirs] = "${WORKDIR}" +python patch_do_patch() { + import re + import bb.fetch + + patch_init(d) + + src_uri = (bb.data.getVar('SRC_URI', d, 1) or '').split() + if not src_uri: + return + + patchsetmap = { + "patch": PatchTree, + "quilt": QuiltTree, + } + + cls = patchsetmap[bb.data.getVar('PATCHTOOL', d, 1) or 'quilt'] + + resolvermap = { + "user": UserResolver, + } + + rcls = resolvermap[bb.data.getVar('PATCHRESOLVE', d, 1) or 'user'] + + s = bb.data.getVar('S', d, 1) + + path = os.getenv('PATH') + os.putenv('PATH', bb.data.getVar('PATH', d, 1)) + patchset = cls(s, d) + patchset.Clean() + + resolver = rcls(patchset) + + workdir = bb.data.getVar('WORKDIR', d, 1) + for url in src_uri: + (type, host, path, user, pswd, parm) = bb.decodeurl(url) + if not "patch" in parm: + continue + + bb.fetch.init([url],d) + url = bb.encodeurl((type, host, path, user, pswd, [])) + local = os.path.join('/', bb.fetch.localpath(url, d)) + + # did it need to be unpacked? + dots = os.path.basename(local).split(".") + if dots[-1] in ['gz', 'bz2', 'Z']: + unpacked = os.path.join(bb.data.getVar('WORKDIR', d),'.'.join(dots[0:-1])) + else: + unpacked = local + unpacked = bb.data.expand(unpacked, d) + + if "pnum" in parm: + pnum = parm["pnum"] + else: + pnum = "1" + + if "pname" in parm: + pname = parm["pname"] + else: + pname = os.path.basename(unpacked) + + if "mindate" in parm: + mindate = parm["mindate"] + else: + mindate = 0 + + if "maxdate" in parm: + maxdate = parm["maxdate"] + else: + maxdate = "20711226" + + pn = bb.data.getVar('PN', d, 1) + srcdate = bb.data.getVar('SRCDATE_%s' % pn, d, 1) + + if not srcdate: + srcdate = bb.data.getVar('SRCDATE', d, 1) + + if srcdate == "now": + srcdate = bb.data.getVar('DATE', d, 1) + + if (maxdate < srcdate) or (mindate > srcdate): + if (maxdate < srcdate): + bb.note("Patch '%s' is outdated" % pname) + + if (mindate > srcdate): + bb.note("Patch '%s' is predated" % pname) + + continue + + bb.note("Applying patch '%s'" % pname) + try: + patchset.Import({"file":unpacked, "remote":url, "strippath": pnum}, True) + except NotFoundError: + import sys + raise bb.build.FuncFailed(str(sys.exc_value)) + resolver.Resolve() +} + +EXPORT_FUNCTIONS do_patch -- cgit v1.2.3 From 4b58334866dda9b3415fee5668b2c7bc08447905 Mon Sep 17 00:00:00 2001 From: Jamie Lenehan Date: Wed, 30 Aug 2006 07:18:07 +0000 Subject: classes/patch.bbclass: Create a "patches" directory when initialising the quilt patcher class. Without this quilt will search for a patches directory - starting from the current directory up to the root directory. If it finds an existing patches directory it will use it for its patches. This causes all sorts of problems since it is not where the patches are expected to be. Prior to the recent patcher changes this directory was being created. --- classes/patch.bbclass | 3 +++ 1 file changed, 3 insertions(+) (limited to 'classes') diff --git a/classes/patch.bbclass b/classes/patch.bbclass index ea0182484e..c62a8ebd76 100644 --- a/classes/patch.bbclass +++ b/classes/patch.bbclass @@ -174,6 +174,9 @@ def patch_init(d): def __init__(self, dir, d): PatchSet.__init__(self, dir, d) self.initialized = False + p = os.path.join(self.dir, 'patches') + if not os.path.exists(p): + os.mkdir(p) def Clean(self): try: -- cgit v1.2.3 From dc8d0a5f1ea8956bc4af88132472cccde4a0e7c3 Mon Sep 17 00:00:00 2001 From: Chris Larson Date: Wed, 30 Aug 2006 07:29:56 +0000 Subject: patch.bbclass: * Add NOOPResolver class, which simply passes the patch failure on up, not doing any actual patch resolution. Set PATCHRESOLVE = "noop" to make use of it. Most useful for unattended builds. --- classes/patch.bbclass | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) (limited to 'classes') diff --git a/classes/patch.bbclass b/classes/patch.bbclass index c62a8ebd76..7bb0900f8a 100644 --- a/classes/patch.bbclass +++ b/classes/patch.bbclass @@ -309,6 +309,19 @@ def patch_init(d): def Finalize(self): raise NotImplementedError() + class NOOPResolver(Resolver): + def __init__(self, patchset): + self.patchset = patchset + + def Resolve(self): + olddir = os.path.abspath(os.curdir) + os.chdir(self.patchset.dir) + try: + self.patchset.Push() + except Exception: + os.chdir(olddir) + raise sys.exc_value + # Patch resolver which relies on the user doing all the work involved in the # resolution, with the exception of refreshing the remote copy of the patch # files (the urls). @@ -360,20 +373,13 @@ def patch_init(d): raise os.chdir(olddir) - # Throw away the changes to the patches in the patchset made by resolve() - def Revert(self): - raise NotImplementedError() - - # Apply the changes to the patches in the patchset made by resolve() - def Finalize(self): - raise NotImplementedError() - g = globals() g["PatchSet"] = PatchSet g["PatchTree"] = PatchTree g["QuiltTree"] = QuiltTree g["Resolver"] = Resolver g["UserResolver"] = UserResolver + g["NOOPResolver"] = NOOPResolver g["NotFoundError"] = NotFoundError g["CmdError"] = CmdError @@ -397,6 +403,7 @@ python patch_do_patch() { cls = patchsetmap[bb.data.getVar('PATCHTOOL', d, 1) or 'quilt'] resolvermap = { + "noop": NOOPResolver, "user": UserResolver, } -- cgit v1.2.3 From ee5c15c58188e02db43e54b9093d9c0f73696182 Mon Sep 17 00:00:00 2001 From: Chris Larson Date: Wed, 30 Aug 2006 08:32:22 +0000 Subject: patch.bbclass: * switch os.mkdir to os.makedirs. * pass on all errors from QuiltTree.Clean(), as it can fail in ways that do not need to be reported to the user, and a failure will end up being seen again during the Import/Push of the patches. --- classes/patch.bbclass | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'classes') diff --git a/classes/patch.bbclass b/classes/patch.bbclass index 7bb0900f8a..5e40b3dc0d 100644 --- a/classes/patch.bbclass +++ b/classes/patch.bbclass @@ -176,16 +176,13 @@ def patch_init(d): self.initialized = False p = os.path.join(self.dir, 'patches') if not os.path.exists(p): - os.mkdir(p) + os.makedirs(p) def Clean(self): try: self._runcmd(["pop", "-a", "-f"]) - except CmdError: - pass - except NotFoundError: + except Exception: pass - # runcmd(["rm", "-rf", os.path.join(self.dir, "patches"), os.path.join(self.dir, ".pc")]) self.initialized = True def InitFromDir(self): -- cgit v1.2.3 From dc05d36fb3e799566cb1325f4d1f0ca018207f57 Mon Sep 17 00:00:00 2001 From: Holger Freyther Date: Sun, 3 Sep 2006 21:51:36 +0000 Subject: classes/sanity.bbclass: Check for bzip2 in the path as well --- classes/sanity.bbclass | 3 +++ 1 file changed, 3 insertions(+) (limited to 'classes') diff --git a/classes/sanity.bbclass b/classes/sanity.bbclass index 91ca9865fd..23a8f656b2 100644 --- a/classes/sanity.bbclass +++ b/classes/sanity.bbclass @@ -97,6 +97,9 @@ def check_sanity(e): if not check_app_exists('svn', e.data): raise_sanity_error('Please install the svn utility') + if not check_app_exists('bzip2', e.data): + raise_sanity_error('Please install the bzip2 utility') + oes_bb_conf = data.getVar( 'OES_BITBAKE_CONF', e.data, True ) if not oes_bb_conf: raise_sanity_error('You do not include OpenEmbeddeds version of conf/bitbake.conf') -- cgit v1.2.3 From 331ec17a16ea8be41fe2a0e5c4fa272b568f319b Mon Sep 17 00:00:00 2001 From: Chris Larson Date: Tue, 5 Sep 2006 11:32:08 +0000 Subject: patch.bbclass: fix issue encountered by zecke, where PatchTree was only doing a --dry-run, never actually applying the patch. Only quilt-native in oe was using that. --- classes/patch.bbclass | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) (limited to 'classes') diff --git a/classes/patch.bbclass b/classes/patch.bbclass index 5e40b3dc0d..f0232adf1e 100644 --- a/classes/patch.bbclass +++ b/classes/patch.bbclass @@ -120,21 +120,20 @@ def patch_init(d): self.patches.insert(self._current or 0, patch) def _applypatch(self, patch, force = None, reverse = None): - shellcmd = ["patch", "<", patch['file'], "-p", patch['strippath']] + shellcmd = ["cat", patch['file'], "|", "patch", "-p", patch['strippath']] if reverse: shellcmd.append('-R') - shellcmd.append('--dry-run') - try: - output = runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) - except CmdError: - if force: - shellcmd.pop(len(shellcmd) - 1) - output = runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) - else: - import sys - raise sys.exc_value + if not force: + shellcmd.append('--dry-run') + + output = runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) + + if force: + return + shellcmd.pop(len(shellcmd) - 1) + output = runcmd(["sh", "-c", " ".join(shellcmd)], self.dir) return output def Push(self, force = None, all = None): -- cgit v1.2.3 From df4ea569ef7a9c2b0498fa924280acbd580de94a Mon Sep 17 00:00:00 2001 From: Chris Larson Date: Tue, 5 Sep 2006 19:23:39 +0000 Subject: patch.bbclass: Fix bug in PatchTree.Import resulting in new patches being imported -before- the current patch rather than -after-. --- classes/patch.bbclass | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) (limited to 'classes') diff --git a/classes/patch.bbclass b/classes/patch.bbclass index f0232adf1e..e3b89ba4f9 100644 --- a/classes/patch.bbclass +++ b/classes/patch.bbclass @@ -117,7 +117,11 @@ def patch_init(d): """""" PatchSet.Import(self, patch, force) - self.patches.insert(self._current or 0, patch) + if self._current is not None: + i = self._current + 1 + else: + i = 0 + self.patches.insert(i, patch) def _applypatch(self, patch, force = None, reverse = None): shellcmd = ["cat", patch['file'], "|", "patch", "-p", patch['strippath']] @@ -137,18 +141,22 @@ def patch_init(d): return output def Push(self, force = None, all = None): + bb.note("self._current is %s" % self._current) + bb.note("patches is %s" % self.patches) if all: for i in self.patches: if self._current is not None: self._current = self._current + 1 else: self._current = 0 + bb.note("applying patch %s" % i) self._applypatch(i, force) else: if self._current is not None: self._current = self._current + 1 else: self._current = 0 + bb.note("applying patch %s" % self.patches[self._current]) self._applypatch(self.patches[self._current], force) -- cgit v1.2.3 From 3991d9efe92fa183899a15fdf928582f53044bbe Mon Sep 17 00:00:00 2001 From: Chris Larson Date: Tue, 5 Sep 2006 20:09:10 +0000 Subject: Add 'rebuild' task to base.bbclass, as it's quite useful and simple to add. --- classes/base.bbclass | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'classes') diff --git a/classes/base.bbclass b/classes/base.bbclass index 51b6d2111f..80e0b82198 100644 --- a/classes/base.bbclass +++ b/classes/base.bbclass @@ -324,6 +324,16 @@ python base_do_clean() { os.system('rm -f '+ dir) } +addtask rebuild +do_rebuild[dirs] = "${TOPDIR}" +do_rebuild[nostamp] = "1" +do_rebuild[bbdepcmd] = "" +python base_do_rebuild() { + """rebuild a package""" + bb.build.exec_task('do_clean', d) + bb.build.exec_task('do_' + bb.data.getVar('BB_DEFAULT_TASK', d, 1), d) +} + addtask mrproper do_mrproper[dirs] = "${TOPDIR}" do_mrproper[nostamp] = "1" @@ -685,7 +695,7 @@ python () { # Patch handling inherit patch -EXPORT_FUNCTIONS do_clean do_mrproper do_fetch do_unpack do_configure do_compile do_install do_package do_populate_pkgs do_stage +EXPORT_FUNCTIONS do_clean do_mrproper do_fetch do_unpack do_configure do_compile do_install do_package do_populate_pkgs do_stage do_rebuild MIRRORS[func] = "0" MIRRORS () { -- cgit v1.2.3 From 93c40996e9da30e39a06cffd85b3fdc403d71c47 Mon Sep 17 00:00:00 2001 From: Chris Larson Date: Fri, 8 Sep 2006 08:08:58 +0000 Subject: package.bbclass: Make legitimize_package_name also convert style encoding of unicode codepoints into their utf-8 representation, as in glibc locale files. --- classes/package.bbclass | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'classes') diff --git a/classes/package.bbclass b/classes/package.bbclass index 9b913ecf82..03999a54ef 100644 --- a/classes/package.bbclass +++ b/classes/package.bbclass @@ -1,4 +1,15 @@ def legitimize_package_name(s): + import re + + def fixutf(m): + cp = m.group(1) + if cp: + return ('\u%s' % cp).decode('unicode_escape').encode('utf-8') + + # Handle unicode codepoints encoded as , as in glibc locale files. + s = re.sub('', fixutf, s) + + # Remaining package name validity fixes return s.lower().replace('_', '-').replace('@', '+').replace(',', '+').replace('/', '-') STAGING_PKGMAPS_DIR ?= "${STAGING_DIR}/pkgmaps" -- cgit v1.2.3