deleted file mode 100755
@@ -1,1384 +0,0 @@
-#!/usr/bin/env python3
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright 2011 Intel Corporation
-# Authored-by: Yu Ke <ke.yu@intel.com>
-# Paul Eggleton <paul.eggleton@intel.com>
-# Richard Purdie <richard.purdie@intel.com>
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-
-import fnmatch
-import os, sys
-import optparse
-import logging
-import subprocess
-import tempfile
-import configparser
-import re
-import copy
-import shlex
-import shutil
-from string import Template
-from functools import reduce
-
-__version__ = "0.2.1"
-
-def logger_create():
- logger = logging.getLogger("")
- loggerhandler = logging.StreamHandler()
- loggerhandler.setFormatter(logging.Formatter("[%(asctime)s] %(message)s","%H:%M:%S"))
- logger.addHandler(loggerhandler)
- logger.setLevel(logging.INFO)
- return logger
-
-logger = logger_create()
-
-def get_current_branch(repodir=None):
- try:
- if not os.path.exists(os.path.join(repodir if repodir else '', ".git")):
- # Repo not created yet (i.e. during init) so just assume master
- return "master"
- branchname = runcmd("git symbolic-ref HEAD 2>/dev/null", repodir).strip()
- if branchname.startswith("refs/heads/"):
- branchname = branchname[11:]
- return branchname
- except subprocess.CalledProcessError:
- return ""
-
-class Configuration(object):
- """
- Manages the configuration
-
- For an example config file, see combo-layer.conf.example
-
- """
- def __init__(self, options):
- for key, val in options.__dict__.items():
- setattr(self, key, val)
-
- def readsection(parser, section, repo):
- for (name, value) in parser.items(section):
- if value.startswith("@"):
- self.repos[repo][name] = eval(value.strip("@"))
- else:
- # Apply special type transformations for some properties.
- # Type matches the RawConfigParser.get*() methods.
- types = {'signoff': 'boolean', 'update': 'boolean', 'history': 'boolean'}
- if name in types:
- value = getattr(parser, 'get' + types[name])(section, name)
- self.repos[repo][name] = value
-
- def readglobalsection(parser, section):
- for (name, value) in parser.items(section):
- if name == "commit_msg":
- self.commit_msg_template = value
-
- logger.debug("Loading config file %s" % self.conffile)
- self.parser = configparser.ConfigParser()
- with open(self.conffile) as f:
- self.parser.read_file(f)
-
- # initialize default values
- self.commit_msg_template = "Automatic commit to update last_revision"
-
- self.repos = {}
- for repo in self.parser.sections():
- if repo == "combo-layer-settings":
- # special handling for global settings
- readglobalsection(self.parser, repo)
- else:
- self.repos[repo] = {}
- readsection(self.parser, repo, repo)
-
- # Load local configuration, if available
- self.localconffile = None
- self.localparser = None
- self.combobranch = None
- if self.conffile.endswith('.conf'):
- lcfile = self.conffile.replace('.conf', '-local.conf')
- if os.path.exists(lcfile):
- # Read combo layer branch
- self.combobranch = get_current_branch()
- logger.debug("Combo layer branch is %s" % self.combobranch)
-
- self.localconffile = lcfile
- logger.debug("Loading local config file %s" % self.localconffile)
- self.localparser = configparser.ConfigParser()
- with open(self.localconffile) as f:
- self.localparser.readfp(f)
-
- for section in self.localparser.sections():
- if '|' in section:
- sectionvals = section.split('|')
- repo = sectionvals[0]
- if sectionvals[1] != self.combobranch:
- continue
- else:
- repo = section
- if repo in self.repos:
- readsection(self.localparser, section, repo)
-
- def update(self, repo, option, value, initmode=False):
- # If the main config has the option already, that is what we
- # are expected to modify.
- if self.localparser and not self.parser.has_option(repo, option):
- parser = self.localparser
- section = "%s|%s" % (repo, self.combobranch)
- conffile = self.localconffile
- if initmode and not parser.has_section(section):
- parser.add_section(section)
- else:
- parser = self.parser
- section = repo
- conffile = self.conffile
- parser.set(section, option, value)
- with open(conffile, "w") as f:
- parser.write(f)
- self.repos[repo][option] = value
-
- def sanity_check(self, initmode=False):
- required_options=["src_uri", "local_repo_dir", "dest_dir", "last_revision"]
- if initmode:
- required_options.remove("last_revision")
- msg = ""
- missing_options = []
- for name in self.repos:
- for option in required_options:
- if option not in self.repos[name]:
- msg = "%s\nOption %s is not defined for component %s" %(msg, option, name)
- missing_options.append(option)
- # Sanitize dest_dir so that we do not have to deal with edge cases
- # (unset, empty string, double slashes) in the rest of the code.
- # It not being set will still be flagged as error because it is
- # listed as required option above; that could be changed now.
- dest_dir = os.path.normpath(self.repos[name].get("dest_dir", "."))
- self.repos[name]["dest_dir"] = "." if not dest_dir else dest_dir
- if msg != "":
- logger.error("configuration file %s has the following error: %s" % (self.conffile,msg))
- if self.localconffile and 'last_revision' in missing_options:
- logger.error("local configuration file %s may be missing configuration for combo branch %s" % (self.localconffile, self.combobranch))
- sys.exit(1)
-
- # filterdiff is required by action_splitpatch, so check its availability
- if subprocess.call("which filterdiff > /dev/null 2>&1", shell=True) != 0:
- logger.error("ERROR: patchutils package is missing, please install it (e.g. # apt-get install patchutils)")
- sys.exit(1)
-
-def runcmd(cmd,destdir=None,printerr=True,out=None,env=None):
- """
- execute command, raise CalledProcessError if fail
- return output if succeed
- """
- logger.debug("run cmd '%s' in %s" % (cmd, os.getcwd() if destdir is None else destdir))
- if not out:
- out = tempfile.TemporaryFile()
- err = out
- else:
- err = tempfile.TemporaryFile()
- try:
- subprocess.check_call(cmd, stdout=out, stderr=err, cwd=destdir, shell=isinstance(cmd, str), env=env or os.environ)
- except subprocess.CalledProcessError as e:
- err.seek(0)
- if printerr:
- logger.error("%s" % err.read())
- raise e
-
- err.seek(0)
- output = err.read().decode('utf-8')
- logger.debug("output: %s" % output.replace(chr(0), '\\0'))
- return output
-
-def action_sync_revs(conf, args):
- """
- Update the last_revision config option for each repo with the latest
- revision in the remote's branch. Useful if multiple people are using
- combo-layer.
- """
- repos = get_repos(conf, args[1:])
-
- for name in repos:
- repo = conf.repos[name]
- ldir = repo['local_repo_dir']
- branch = repo.get('branch', "master")
- runcmd("git fetch", ldir)
- lastrev = runcmd('git rev-parse origin/%s' % branch, ldir).strip()
- print("Updating %s to %s" % (name, lastrev))
- conf.update(name, "last_revision", lastrev)
-
-def action_init(conf, args):
- """
- Clone component repositories
- Check git is initialised; if not, copy initial data from component repos
- """
- for name in conf.repos:
- ldir = conf.repos[name]['local_repo_dir']
- if not os.path.exists(ldir):
- logger.info("cloning %s to %s" %(conf.repos[name]['src_uri'], ldir))
- subprocess.check_call("git clone %s %s" % (conf.repos[name]['src_uri'], ldir), shell=True)
- if not os.path.exists(".git"):
- runcmd("git init")
- if conf.history:
- # Need a common ref for all trees.
- runcmd('git commit -m "initial empty commit" --allow-empty')
- startrev = runcmd('git rev-parse master').strip()
-
- for name in conf.repos:
- repo = conf.repos[name]
- ldir = repo['local_repo_dir']
- branch = repo.get('branch', "master")
- lastrev = repo.get('last_revision', None)
- if lastrev and lastrev != "HEAD":
- initialrev = lastrev
- if branch:
- if not check_rev_branch(name, ldir, lastrev, branch):
- sys.exit(1)
- logger.info("Copying data from %s at specified revision %s..." % (name, lastrev))
- else:
- lastrev = None
- initialrev = branch
- logger.info("Copying data from %s..." % name)
- # Sanity check initialrev and turn it into hash (required for copying history,
- # because resolving a name ref only works in the component repo).
- rev = runcmd('git rev-parse %s' % initialrev, ldir).strip()
- if rev != initialrev:
- try:
- refs = runcmd('git show-ref -s %s' % initialrev, ldir).split('\n')
- if len(set(refs)) > 1:
- # Happens for example when configured to track
- # "master" and there is a refs/heads/master. The
- # traditional behavior from "git archive" (preserved
- # here) it to choose the first one. This might not be
- # intended, so at least warn about it.
- logger.warning("%s: initial revision '%s' not unique, picking result of rev-parse = %s" %
- (name, initialrev, refs[0]))
- initialrev = rev
- except:
- # show-ref fails for hashes. Skip the sanity warning in that case.
- pass
- initialrev = rev
- dest_dir = repo['dest_dir']
- if dest_dir != ".":
- extract_dir = os.path.join(os.getcwd(), dest_dir)
- if not os.path.exists(extract_dir):
- os.makedirs(extract_dir)
- else:
- extract_dir = os.getcwd()
- file_filter = repo.get('file_filter', "")
- exclude_patterns = repo.get('file_exclude', '').split()
- def copy_selected_files(initialrev, extract_dir, file_filter, exclude_patterns, ldir,
- subdir=""):
- # When working inside a filtered branch which had the
- # files already moved, we need to prepend the
- # subdirectory to all filters, otherwise they would
- # not match.
- if subdir == '.':
- subdir = ''
- elif subdir:
- subdir = os.path.normpath(subdir)
- file_filter = ' '.join([subdir + '/' + x for x in file_filter.split()])
- exclude_patterns = [subdir + '/' + x for x in exclude_patterns]
- # To handle both cases, we cd into the target
- # directory and optionally tell tar to strip the path
- # prefix when the files were already moved.
- subdir_components = len(subdir.split(os.path.sep)) if subdir else 0
- strip=('--strip-components=%d' % subdir_components) if subdir else ''
- # TODO: file_filter wild cards do not work (and haven't worked before either), because
- # a) GNU tar requires a --wildcards parameter before turning on wild card matching.
- # b) The semantic is not as intendend (src/*.c also matches src/foo/bar.c,
- # in contrast to the other use of file_filter as parameter of "git archive"
- # where it only matches .c files directly in src).
- files = runcmd("git archive %s %s | tar -x -v %s -C %s %s" %
- (initialrev, subdir,
- strip, extract_dir, file_filter),
- ldir)
- if exclude_patterns:
- # Implement file removal by letting tar create the
- # file and then deleting it in the file system
- # again. Uses the list of files created by tar (easier
- # than walking the tree).
- for file in files.split('\n'):
- if file.endswith(os.path.sep):
- continue
- for pattern in exclude_patterns:
- if fnmatch.fnmatch(file, pattern):
- os.unlink(os.path.join(*([extract_dir] + ['..'] * subdir_components + [file])))
- break
-
- if not conf.history:
- copy_selected_files(initialrev, extract_dir, file_filter, exclude_patterns, ldir)
- else:
- # First fetch remote history into local repository.
- # We need a ref for that, so ensure that there is one.
- refname = "combo-layer-init-%s" % name
- runcmd("git branch -f %s %s" % (refname, initialrev), ldir)
- runcmd("git fetch %s %s" % (ldir, refname))
- runcmd("git branch -D %s" % refname, ldir)
- # Make that the head revision.
- runcmd("git checkout -b %s %s" % (name, initialrev))
- # Optional: cut the history by replacing the given
- # start point(s) with commits providing the same
- # content (aka tree), but with commit information that
- # makes it clear that this is an artifically created
- # commit and nothing the original authors had anything
- # to do with.
- since_rev = repo.get('since_revision', '')
- if since_rev:
- committer = runcmd('git var GIT_AUTHOR_IDENT').strip()
- # Same time stamp, no name.
- author = re.sub('.* (\d+ [+-]\d+)', r'unknown <unknown> \1', committer)
- logger.info('author %s' % author)
- for rev in since_rev.split():
- # Resolve in component repo...
- rev = runcmd('git log --oneline --no-abbrev-commit -n1 %s' % rev, ldir).split()[0]
- # ... and then get the tree in current
- # one. The commit should be in both repos with
- # the same tree, but better check here.
- tree = runcmd('git show -s --pretty=format:%%T %s' % rev).strip()
- with tempfile.NamedTemporaryFile(mode='wt') as editor:
- editor.write('''cat >$1 <<EOF
-tree %s
-author %s
-committer %s
-
-%s: squashed import of component
-
-This commit copies the entire set of files as found in
-%s %s
-
-For more information about previous commits, see the
-upstream repository.
-
-Commit created by combo-layer.
-EOF
-''' % (tree, author, committer, name, name, since_rev))
- editor.flush()
- os.environ['GIT_EDITOR'] = 'sh %s' % editor.name
- runcmd('git replace --edit %s' % rev)
-
- # Optional: rewrite history to change commit messages or to move files.
- if 'hook' in repo or dest_dir != ".":
- filter_branch = ['git', 'filter-branch', '--force']
- with tempfile.NamedTemporaryFile(mode='wt') as hookwrapper:
- if 'hook' in repo:
- # Create a shell script wrapper around the original hook that
- # can be used by git filter-branch. Hook may or may not have
- # an absolute path.
- hook = repo['hook']
- hook = os.path.join(os.path.dirname(conf.conffile), '..', hook)
- # The wrappers turns the commit message
- # from stdin into a fake patch header.
- # This is good enough for changing Subject
- # and commit msg body with normal
- # combo-layer hooks.
- hookwrapper.write('''set -e
-tmpname=$(mktemp)
-trap "rm $tmpname" EXIT
-echo -n 'Subject: [PATCH] ' >>$tmpname
-cat >>$tmpname
-if ! [ $(tail -c 1 $tmpname | od -A n -t x1) == '0a' ]; then
- echo >>$tmpname
-fi
-echo '---' >>$tmpname
-%s $tmpname $GIT_COMMIT %s
-tail -c +18 $tmpname | head -c -4
-''' % (hook, name))
- hookwrapper.flush()
- filter_branch.extend(['--msg-filter', 'bash %s' % hookwrapper.name])
- if dest_dir != ".":
- parent = os.path.dirname(dest_dir)
- if not parent:
- parent = '.'
- # May run outside of the current directory, so do not assume that .git exists.
- filter_branch.extend(['--tree-filter', 'mkdir -p .git/tmptree && find . -mindepth 1 -maxdepth 1 ! -name .git -print0 | xargs -0 -I SOURCE mv SOURCE .git/tmptree && mkdir -p %s && mv .git/tmptree %s' % (parent, dest_dir)])
- filter_branch.append('HEAD')
- runcmd(filter_branch)
- runcmd('git update-ref -d refs/original/refs/heads/%s' % name)
- repo['rewritten_revision'] = runcmd('git rev-parse HEAD').strip()
- repo['stripped_revision'] = repo['rewritten_revision']
- # Optional filter files: remove everything and re-populate using the normal filtering code.
- # Override any potential .gitignore.
- if file_filter or exclude_patterns:
- runcmd('git rm -rf .')
- if not os.path.exists(extract_dir):
- os.makedirs(extract_dir)
- copy_selected_files('HEAD', extract_dir, file_filter, exclude_patterns, '.',
- subdir=dest_dir)
- runcmd('git add --all --force .')
- if runcmd('git status --porcelain'):
- # Something to commit.
- runcmd(['git', 'commit', '-m',
- '''%s: select file subset
-
-Files from the component repository were chosen based on
-the following filters:
-file_filter = %s
-file_exclude = %s''' % (name, file_filter or '<empty>', repo.get('file_exclude', '<empty>'))])
- repo['stripped_revision'] = runcmd('git rev-parse HEAD').strip()
-
- if not lastrev:
- lastrev = runcmd('git rev-parse %s' % initialrev, ldir).strip()
- conf.update(name, "last_revision", lastrev, initmode=True)
-
- if not conf.history:
- runcmd("git add .")
- else:
- # Create Octopus merge commit according to http://stackoverflow.com/questions/10874149/git-octopus-merge-with-unrelated-repositoies
- runcmd('git checkout master')
- merge = ['git', 'merge', '--no-commit']
- for name in conf.repos:
- repo = conf.repos[name]
- # Use branch created earlier.
- merge.append(name)
- # Root all commits which have no parent in the common
- # ancestor in the new repository.
- for start in runcmd('git log --pretty=format:%%H --max-parents=0 %s --' % name).split('\n'):
- runcmd('git replace --graft %s %s' % (start, startrev))
- try:
- runcmd(merge)
- except Exception as error:
- logger.info('''Merging component repository history failed, perhaps because of merge conflicts.
-It may be possible to commit anyway after resolving these conflicts.
-
-%s''' % error)
- # Create MERGE_HEAD and MERGE_MSG. "git merge" itself
- # does not create MERGE_HEAD in case of a (harmless) failure,
- # and we want certain auto-generated information in the
- # commit message for future reference and/or automation.
- with open('.git/MERGE_HEAD', 'w') as head:
- with open('.git/MERGE_MSG', 'w') as msg:
- msg.write('repo: initial import of components\n\n')
- # head.write('%s\n' % startrev)
- for name in conf.repos:
- repo = conf.repos[name]
- # <upstream ref> <rewritten ref> <rewritten + files removed>
- msg.write('combo-layer-%s: %s %s %s\n' % (name,
- repo['last_revision'],
- repo['rewritten_revision'],
- repo['stripped_revision']))
- rev = runcmd('git rev-parse %s' % name).strip()
- head.write('%s\n' % rev)
-
- if conf.localconffile:
- localadded = True
- try:
- runcmd("git rm --cached %s" % conf.localconffile, printerr=False)
- except subprocess.CalledProcessError:
- localadded = False
- if localadded:
- localrelpath = os.path.relpath(conf.localconffile)
- runcmd("grep -q %s .gitignore || echo %s >> .gitignore" % (localrelpath, localrelpath))
- runcmd("git add .gitignore")
- logger.info("Added local configuration file %s to .gitignore", localrelpath)
- logger.info("Initial combo layer repository data has been created; please make any changes if desired and then use 'git commit' to make the initial commit.")
- else:
- logger.info("Repository already initialised, nothing to do.")
-
-
-def check_repo_clean(repodir):
- """
- check if the repo is clean
- exit if repo is dirty
- """
- output=runcmd("git status --porcelain", repodir)
- r = re.compile(r'\?\? patch-.*/')
- dirtyout = [item for item in output.splitlines() if not r.match(item)]
- if dirtyout:
- logger.error("git repo %s is dirty, please fix it first", repodir)
- sys.exit(1)
-
-def check_patch(patchfile):
- f = open(patchfile, 'rb')
- ln = f.readline()
- of = None
- in_patch = False
- beyond_msg = False
- pre_buf = b''
- while ln:
- if not beyond_msg:
- if ln == b'---\n':
- if not of:
- break
- in_patch = False
- beyond_msg = True
- elif ln.startswith(b'--- '):
- # We have a diff in the commit message
- in_patch = True
- if not of:
- print('WARNING: %s contains a diff in its commit message, indenting to avoid failure during apply' % patchfile)
- of = open(patchfile + '.tmp', 'wb')
- of.write(pre_buf)
- pre_buf = b''
- elif in_patch and not ln[0] in b'+-@ \n\r':
- in_patch = False
- if of:
- if in_patch:
- of.write(b' ' + ln)
- else:
- of.write(ln)
- else:
- pre_buf += ln
- ln = f.readline()
- f.close()
- if of:
- of.close()
- os.rename(of.name, patchfile)
-
-def drop_to_shell(workdir=None):
- if not sys.stdin.isatty():
- print("Not a TTY so can't drop to shell for resolution, exiting.")
- return False
-
- shell = os.environ.get('SHELL', 'bash')
- print('Dropping to shell "%s"\n' \
- 'When you are finished, run the following to continue:\n' \
- ' exit -- continue to apply the patches\n' \
- ' exit 1 -- abort\n' % shell);
- ret = subprocess.call([shell], cwd=workdir)
- if ret != 0:
- print("Aborting")
- return False
- else:
- return True
-
-def check_rev_branch(component, repodir, rev, branch):
- try:
- actualbranch = runcmd("git branch --contains %s" % rev, repodir, printerr=False)
- except subprocess.CalledProcessError as e:
- if e.returncode == 129:
- actualbranch = ""
- else:
- raise
-
- if not actualbranch:
- logger.error("%s: specified revision %s is invalid!" % (component, rev))
- return False
-
- branches = []
- branchlist = actualbranch.split("\n")
- for b in branchlist:
- branches.append(b.strip().split(' ')[-1])
-
- if branch not in branches:
- logger.error("%s: specified revision %s is not on specified branch %s!" % (component, rev, branch))
- return False
- return True
-
-def get_repos(conf, repo_names):
- repos = []
- for name in repo_names:
- if name.startswith('-'):
- break
- else:
- repos.append(name)
- for repo in repos:
- if not repo in conf.repos:
- logger.error("Specified component '%s' not found in configuration" % repo)
- sys.exit(1)
-
- if not repos:
- repos = [ repo for repo in conf.repos if conf.repos[repo].get("update", True) ]
-
- return repos
-
-def action_pull(conf, args):
- """
- update the component repos only
- """
- repos = get_repos(conf, args[1:])
-
- # make sure all repos are clean
- for name in repos:
- check_repo_clean(conf.repos[name]['local_repo_dir'])
-
- for name in repos:
- repo = conf.repos[name]
- ldir = repo['local_repo_dir']
- branch = repo.get('branch', "master")
- logger.info("update branch %s of component repo %s in %s ..." % (branch, name, ldir))
- if not conf.hard_reset:
- # Try to pull only the configured branch. Beware that this may fail
- # when the branch is currently unknown (for example, after reconfiguring
- # combo-layer). In that case we need to fetch everything and try the check out
- # and pull again.
- try:
- runcmd("git checkout %s" % branch, ldir, printerr=False)
- except subprocess.CalledProcessError:
- output=runcmd("git fetch", ldir)
- logger.info(output)
- runcmd("git checkout %s" % branch, ldir)
- runcmd("git pull --ff-only", ldir)
- else:
- output=runcmd("git pull --ff-only", ldir)
- logger.info(output)
- else:
- output=runcmd("git fetch", ldir)
- logger.info(output)
- runcmd("git checkout %s" % branch, ldir)
- runcmd("git reset --hard FETCH_HEAD", ldir)
-
-def action_update(conf, args):
- """
- update the component repos
- either:
- generate the patch list
- apply the generated patches
- or:
- re-creates the entire component history and merges them
- into the current branch with a merge commit
- """
- components = [arg.split(':')[0] for arg in args[1:]]
- revisions = {}
- for arg in args[1:]:
- if ':' in arg:
- a = arg.split(':', 1)
- revisions[a[0]] = a[1]
- repos = get_repos(conf, components)
-
- # make sure combo repo is clean
- check_repo_clean(os.getcwd())
-
- # Check whether we keep the component histories. Must be
- # set either via --history command line parameter or consistently
- # in combo-layer.conf. Mixing modes is (currently, and probably
- # permanently because it would be complicated) not supported.
- if conf.history:
- history = True
- else:
- history = None
- for name in repos:
- repo = conf.repos[name]
- repo_history = repo.get('history', False)
- if history is None:
- history = repo_history
- elif history != repo_history:
- logger.error("'history' property is set inconsistently")
- sys.exit(1)
-
- # Step 1: update the component repos
- if conf.nopull:
- logger.info("Skipping pull (-n)")
- else:
- action_pull(conf, ['arg0'] + components)
-
- if history:
- update_with_history(conf, components, revisions, repos)
- else:
- update_with_patches(conf, components, revisions, repos)
-
-def update_with_patches(conf, components, revisions, repos):
- import uuid
- patch_dir = "patch-%s" % uuid.uuid4()
- if not os.path.exists(patch_dir):
- os.mkdir(patch_dir)
-
- for name in repos:
- revision = revisions.get(name, None)
- repo = conf.repos[name]
- ldir = repo['local_repo_dir']
- dest_dir = repo['dest_dir']
- branch = repo.get('branch', "master")
- repo_patch_dir = os.path.join(os.getcwd(), patch_dir, name)
-
- # Step 2: generate the patch list and store to patch dir
- logger.info("Generating patches from %s..." % name)
- top_revision = revision or branch
- if not check_rev_branch(name, ldir, top_revision, branch):
- sys.exit(1)
- if dest_dir != ".":
- prefix = "--src-prefix=a/%s/ --dst-prefix=b/%s/" % (dest_dir, dest_dir)
- else:
- prefix = ""
- if repo['last_revision'] == "":
- logger.info("Warning: last_revision of component %s is not set, starting from the first commit" % name)
- patch_cmd_range = "--root %s" % top_revision
- rev_cmd_range = top_revision
- else:
- if not check_rev_branch(name, ldir, repo['last_revision'], branch):
- sys.exit(1)
- patch_cmd_range = "%s..%s" % (repo['last_revision'], top_revision)
- rev_cmd_range = patch_cmd_range
-
- file_filter = repo.get('file_filter',".")
-
- # Filter out unwanted files
- exclude = repo.get('file_exclude', '')
- if exclude:
- for path in exclude.split():
- p = "%s/%s" % (dest_dir, path) if dest_dir != '.' else path
- file_filter += " ':!%s'" % p
-
- patch_cmd = "git format-patch -N %s --output-directory %s %s -- %s" % \
- (prefix,repo_patch_dir, patch_cmd_range, file_filter)
- output = runcmd(patch_cmd, ldir)
- logger.debug("generated patch set:\n%s" % output)
- patchlist = output.splitlines()
-
- rev_cmd = "git rev-list --no-merges %s -- %s" % (rev_cmd_range, file_filter)
- revlist = runcmd(rev_cmd, ldir).splitlines()
-
- # Step 3: Call repo specific hook to adjust patch
- if 'hook' in repo:
- # hook parameter is: ./hook patchpath revision reponame
- count=len(revlist)-1
- for patch in patchlist:
- runcmd("%s %s %s %s" % (repo['hook'], patch, revlist[count], name))
- count=count-1
-
- # Step 4: write patch list and revision list to file, for user to edit later
- patchlist_file = os.path.join(os.getcwd(), patch_dir, "patchlist-%s" % name)
- repo['patchlist'] = patchlist_file
- f = open(patchlist_file, 'w')
- count=len(revlist)-1
- for patch in patchlist:
- f.write("%s %s\n" % (patch, revlist[count]))
- check_patch(os.path.join(patch_dir, patch))
- count=count-1
- f.close()
-
- # Step 5: invoke bash for user to edit patch and patch list
- if conf.interactive:
- print('You may now edit the patch and patch list in %s\n' \
- 'For example, you can remove unwanted patch entries from patchlist-*, so that they will be not applied later' % patch_dir);
- if not drop_to_shell(patch_dir):
- sys.exit(1)
-
- # Step 6: apply the generated and revised patch
- apply_patchlist(conf, repos)
- runcmd("rm -rf %s" % patch_dir)
-
- # Step 7: commit the updated config file if it's being tracked
- commit_conf_file(conf, components)
-
-def conf_commit_msg(conf, components):
- # create the "components" string
- component_str = "all components"
- if len(components) > 0:
- # otherwise tell which components were actually changed
- component_str = ", ".join(components)
-
- # expand the template with known values
- template = Template(conf.commit_msg_template)
- msg = template.substitute(components = component_str)
- return msg
-
-def commit_conf_file(conf, components, commit=True):
- relpath = os.path.relpath(conf.conffile)
- try:
- output = runcmd("git status --porcelain %s" % relpath, printerr=False)
- except:
- # Outside the repository
- output = None
- if output:
- if output.lstrip().startswith("M"):
- logger.info("Committing updated configuration file")
- if commit:
- msg = conf_commit_msg(conf, components)
- runcmd('git commit -m'.split() + [msg, relpath])
- else:
- runcmd('git add %s' % relpath)
- return True
- return False
-
-def apply_patchlist(conf, repos):
- """
- apply the generated patch list to combo repo
- """
- for name in repos:
- repo = conf.repos[name]
- lastrev = repo["last_revision"]
- prevrev = lastrev
-
- # Get non-blank lines from patch list file
- patchlist = []
- if os.path.exists(repo['patchlist']) or not conf.interactive:
- # Note: we want this to fail here if the file doesn't exist and we're not in
- # interactive mode since the file should exist in this case
- with open(repo['patchlist']) as f:
- for line in f:
- line = line.rstrip()
- if line:
- patchlist.append(line)
-
- ldir = conf.repos[name]['local_repo_dir']
- branch = conf.repos[name].get('branch', "master")
- branchrev = runcmd("git rev-parse %s" % branch, ldir).strip()
-
- if patchlist:
- logger.info("Applying patches from %s..." % name)
- linecount = len(patchlist)
- i = 1
- for line in patchlist:
- patchfile = line.split()[0]
- lastrev = line.split()[1]
- patchdisp = os.path.relpath(patchfile)
- if os.path.getsize(patchfile) == 0:
- logger.info("(skipping %d/%d %s - no changes)" % (i, linecount, patchdisp))
- else:
- cmd = "git am --keep-cr %s-p1 %s" % ('-s ' if repo.get('signoff', True) else '', patchfile)
- logger.info("Applying %d/%d: %s" % (i, linecount, patchdisp))
- try:
- runcmd(cmd)
- except subprocess.CalledProcessError:
- logger.info('Running "git am --abort" to cleanup repo')
- runcmd("git am --abort")
- logger.error('"%s" failed' % cmd)
- logger.info("Please manually apply patch %s" % patchdisp)
- logger.info("Note: if you exit and continue applying without manually applying the patch, it will be skipped")
- if not drop_to_shell():
- if prevrev != repo['last_revision']:
- conf.update(name, "last_revision", prevrev)
- sys.exit(1)
- prevrev = lastrev
- i += 1
- # Once all patches are applied, we should update
- # last_revision to the branch head instead of the last
- # applied patch. The two are not necessarily the same when
- # the last commit is a merge commit or when the patches at
- # the branch head were intentionally excluded.
- #
- # If we do not do that for a merge commit, the next
- # combo-layer run will only exclude patches reachable from
- # one of the merged branches and try to re-apply patches
- # from other branches even though they were already
- # copied.
- #
- # If patches were intentionally excluded, the next run will
- # present them again instead of skipping over them. This
- # may or may not be intended, so the code here is conservative
- # and only addresses the "head is merge commit" case.
- if lastrev != branchrev and \
- len(runcmd("git show --pretty=format:%%P --no-patch %s" % branch, ldir).split()) > 1:
- lastrev = branchrev
- else:
- logger.info("No patches to apply from %s" % name)
- lastrev = branchrev
-
- if lastrev != repo['last_revision']:
- conf.update(name, "last_revision", lastrev)
-
-def action_splitpatch(conf, args):
- """
- generate the commit patch and
- split the patch per repo
- """
- logger.debug("action_splitpatch")
- if len(args) > 1:
- commit = args[1]
- else:
- commit = "HEAD"
- patchdir = "splitpatch-%s" % commit
- if not os.path.exists(patchdir):
- os.mkdir(patchdir)
-
- # filerange_root is for the repo whose dest_dir is root "."
- # and it should be specified by excluding all other repo dest dir
- # like "-x repo1 -x repo2 -x repo3 ..."
- filerange_root = ""
- for name in conf.repos:
- dest_dir = conf.repos[name]['dest_dir']
- if dest_dir != ".":
- filerange_root = '%s -x "%s/*"' % (filerange_root, dest_dir)
-
- for name in conf.repos:
- dest_dir = conf.repos[name]['dest_dir']
- patch_filename = "%s/%s.patch" % (patchdir, name)
- if dest_dir == ".":
- cmd = "git format-patch -n1 --stdout %s^..%s | filterdiff -p1 %s > %s" % (commit, commit, filerange_root, patch_filename)
- else:
- cmd = "git format-patch --no-prefix -n1 --stdout %s^..%s -- %s > %s" % (commit, commit, dest_dir, patch_filename)
- runcmd(cmd)
- # Detect empty patches (including those produced by filterdiff above
- # that contain only preamble text)
- if os.path.getsize(patch_filename) == 0 or runcmd("filterdiff %s" % patch_filename) == "":
- os.remove(patch_filename)
- logger.info("(skipping %s - no changes)", name)
- else:
- logger.info(patch_filename)
-
-def update_with_history(conf, components, revisions, repos):
- '''Update all components with full history.
-
- Works by importing all commits reachable from a component's
- current head revision. If those commits are rooted in an already
- imported commit, their content gets mixed with the content of the
- combined repo of that commit (new or modified files overwritten,
- removed files removed).
-
- The last commit is an artificial merge commit that merges all the
- updated components into the combined repository.
-
- The HEAD ref only gets updated at the very end. All intermediate work
- happens in a worktree which will get garbage collected by git eventually
- after a failure.
- '''
- # Remember current HEAD and what we need to add to it.
- head = runcmd("git rev-parse HEAD").strip()
- additional_heads = {}
-
- # Track the mapping between original commit and commit in the
- # combined repo. We do not have to distinguish between components,
- # because commit hashes are different anyway. Often we can
- # skip find_revs() entirely (for example, when all new commits
- # are derived from the last imported revision).
- #
- # Using "head" (typically the merge commit) instead of the actual
- # commit for the component leads to a nicer history in the combined
- # repo.
- old2new_revs = {}
- for name in repos:
- repo = conf.repos[name]
- revision = repo['last_revision']
- if revision:
- old2new_revs[revision] = head
-
- def add_p(parents):
- '''Insert -p before each entry.'''
- parameters = []
- for p in parents:
- parameters.append('-p')
- parameters.append(p)
- return parameters
-
- # Do all intermediate work with a separate work dir and index,
- # chosen via env variables (can't use "git worktree", it is too
- # new). This is useful (no changes to current work tree unless the
- # update succeeds) and required (otherwise we end up temporarily
- # removing the combo-layer hooks that we currently use when
- # importing a new component).
- #
- # Not cleaned up after a failure at the moment.
- wdir = os.path.join(os.getcwd(), ".git", "combo-layer")
- windex = wdir + ".index"
- if os.path.isdir(wdir):
- shutil.rmtree(wdir)
- os.mkdir(wdir)
- wenv = copy.deepcopy(os.environ)
- wenv["GIT_WORK_TREE"] = wdir
- wenv["GIT_INDEX_FILE"] = windex
- # This one turned out to be needed in practice.
- wenv["GIT_OBJECT_DIRECTORY"] = os.path.join(os.getcwd(), ".git", "objects")
- wargs = {"destdir": wdir, "env": wenv}
-
- for name in repos:
- revision = revisions.get(name, None)
- repo = conf.repos[name]
- ldir = repo['local_repo_dir']
- dest_dir = repo['dest_dir']
- branch = repo.get('branch', "master")
- hook = repo.get('hook', None)
- largs = {"destdir": ldir, "env": None}
- file_include = repo.get('file_filter', '').split()
- file_include.sort() # make sure that short entries like '.' come first.
- file_exclude = repo.get('file_exclude', '').split()
-
- def include_file(file):
- if not file_include:
- # No explicit filter set, include file.
- return True
- for filter in file_include:
- if filter == '.':
- # Another special case: include current directory and thus all files.
- return True
- if os.path.commonprefix((filter, file)) == filter:
- # Included in directory or direct file match.
- return True
- # Check for wildcard match *with* allowing * to match /, i.e.
- # src/*.c does match src/foobar/*.c. That's not how it is done elsewhere
- # when passing the filtering to "git archive", but it is unclear what
- # the intended semantic is (the comment on file_exclude that "append a * wildcard
- # at the end" to match the full content of a directories implies that
- # slashes are indeed not special), so here we simply do what's easy to
- # implement in Python.
- logger.debug('fnmatch(%s, %s)' % (file, filter))
- if fnmatch.fnmatchcase(file, filter):
- return True
- return False
-
- def exclude_file(file):
- for filter in file_exclude:
- if fnmatch.fnmatchcase(file, filter):
- return True
- return False
-
- def file_filter(files):
- '''Clean up file list so that only included files remain.'''
- index = 0
- while index < len(files):
- file = files[index]
- if not include_file(file) or exclude_file(file):
- del files[index]
- else:
- index += 1
-
-
- # Generate the revision list.
- logger.info("Analyzing commits from %s..." % name)
- top_revision = revision or branch
- if not check_rev_branch(name, ldir, top_revision, branch):
- sys.exit(1)
-
- last_revision = repo['last_revision']
- rev_list_args = "--full-history --sparse --topo-order --reverse"
- if not last_revision:
- logger.info("Warning: last_revision of component %s is not set, starting from the first commit" % name)
- rev_list_args = rev_list_args + ' ' + top_revision
- else:
- if not check_rev_branch(name, ldir, last_revision, branch):
- sys.exit(1)
- rev_list_args = "%s %s..%s" % (rev_list_args, last_revision, top_revision)
-
- # By definition, the current HEAD contains the latest imported
- # commit of each component. We use that as initial mapping even
- # though the commits do not match exactly because
- # a) it always works (in contrast to find_revs, which relies on special
- # commit messages)
- # b) it is faster than find_revs, which will only be called on demand
- # and can be skipped entirely in most cases
- # c) last but not least, the combined history looks nicer when all
- # new commits are rooted in the same merge commit
- old2new_revs[last_revision] = head
-
- # We care about all commits (--full-history and --sparse) and
- # we want reconstruct the topology and thus do not care
- # about ordering by time (--topo-order). We ask for the ones
- # we need to import first to be listed first (--reverse).
- revs = runcmd("git rev-list %s" % rev_list_args, **largs).split()
- logger.debug("To be imported: %s" % revs)
- # Now 'revs' contains all revisions reachable from the top revision.
- # All revisions derived from the 'last_revision' definitely are new,
- # whereas the others may or may not have been imported before. For
- # a linear history in the component, that second set will be empty.
- # To distinguish between them, we also get the shorter list
- # of revisions starting at the ancestor.
- if last_revision:
- ancestor_revs = runcmd("git rev-list --ancestry-path %s" % rev_list_args, **largs).split()
- else:
- ancestor_revs = []
- logger.debug("Ancestors: %s" % ancestor_revs)
-
- # Now import each revision.
- logger.info("Importing commits from %s..." % name)
- def import_rev(rev):
- global scanned_revs
-
- # If it is part of the new commits, we definitely need
- # to import it. Otherwise we need to check, we might have
- # imported it before. If it was imported and we merely
- # fail to find it because commit messages did not track
- # the mapping, then we end up importing it again. So
- # combined repos using "updating with history" really should
- # enable the "From ... rev:" commit header modifications.
- if rev not in ancestor_revs and rev not in old2new_revs and not scanned_revs:
- logger.debug("Revision %s triggers log analysis." % rev)
- find_revs(old2new_revs, head)
- scanned_revs = True
- new_rev = old2new_revs.get(rev, None)
- if new_rev:
- return new_rev
-
- # If the commit is not in the original list of revisions
- # to be imported, then it must be a parent of one of those
- # commits and it was skipped during earlier imports or not
- # found. Importing such merge commits leads to very ugly
- # history (long cascade of merge commits which all point
- # to to older commits) when switching from "update via
- # patches" to "update with history".
- #
- # We can avoid importing merge commits if all non-merge commits
- # reachable from it were already imported. In that case we
- # can root the new commits in the current head revision.
- def is_imported(prev):
- parents = runcmd("git show --no-patch --pretty=format:%P " + prev, **largs).split()
- if len(parents) > 1:
- for p in parents:
- if not is_imported(p):
- logger.debug("Must import %s because %s is not imported." % (rev, p))
- return False
- return True
- elif prev in old2new_revs:
- return True
- else:
- logger.debug("Must import %s because %s is not imported." % (rev, prev))
- return False
- if rev not in revs and is_imported(rev):
- old2new_revs[rev] = head
- return head
-
- # Need to import rev. Collect some information about it.
- logger.debug("Importing %s" % rev)
- (parents, author_name, author_email, author_timestamp, body) = \
- runcmd("git show --no-patch --pretty=format:%P%x00%an%x00%ae%x00%at%x00%B " + rev, **largs).split(chr(0))
- parents = parents.split()
- if parents:
- # Arbitrarily pick the first parent as base. It may or may not have
- # been imported before. For example, if the parent is a merge commit
- # and previously the combined repository used patching as update
- # method, then the actual merge commit parent never was imported.
- # To cover this, We recursively import parents.
- parent = parents[0]
- new_parent = import_rev(parent)
- # Clean index and working tree. TODO: can we combine this and the
- # next into one command with less file IO?
- # "git reset --hard" does not work, it changes HEAD of the parent
- # repo, which we wanted to avoid. Probably need to keep
- # track of the rev that corresponds to the index and use apply_commit().
- runcmd("git rm -q --ignore-unmatch -rf .", **wargs)
- # Update index and working tree to match the parent.
- runcmd("git checkout -q -f %s ." % new_parent, **wargs)
- else:
- parent = None
- # Clean index and working tree.
- runcmd("git rm -q --ignore-unmatch -rf .", **wargs)
-
- # Modify index and working tree such that it mirrors the commit.
- apply_commit(parent, rev, largs, wargs, dest_dir, file_filter=file_filter)
-
- # Now commit.
- new_tree = runcmd("git write-tree", **wargs).strip()
- env = copy.deepcopy(wenv)
- env['GIT_AUTHOR_NAME'] = author_name
- env['GIT_AUTHOR_EMAIL'] = author_email
- env['GIT_AUTHOR_DATE'] = author_timestamp
- if hook:
- # Need to turn the verbatim commit message into something resembling a patch header
- # for the hook.
- with tempfile.NamedTemporaryFile(mode='wt', delete=False) as patch:
- patch.write('Subject: [PATCH] ')
- patch.write(body)
- patch.write('\n---\n')
- patch.close()
- runcmd([hook, patch.name, rev, name])
- with open(patch.name) as f:
- body = f.read()[len('Subject: [PATCH] '):][:-len('\n---\n')]
-
- # We can skip non-merge commits that did not change any files. Those are typically
- # the result of file filtering, although they could also have been introduced
- # intentionally upstream, in which case we drop some information here.
- if len(parents) == 1:
- parent_rev = import_rev(parents[0])
- old_tree = runcmd("git show -s --pretty=format:%T " + parent_rev, **wargs).strip()
- commit = old_tree != new_tree
- if not commit:
- new_rev = parent_rev
- else:
- commit = True
- if commit:
- new_rev = runcmd("git commit-tree".split() + add_p([import_rev(p) for p in parents]) +
- ["-m", body, new_tree],
- env=env).strip()
- old2new_revs[rev] = new_rev
-
- return new_rev
-
- if revs:
- for rev in revs:
- import_rev(rev)
- # Remember how to update our current head. New components get added,
- # updated components get the delta between current head and the updated component
- # applied.
- additional_heads[old2new_revs[revs[-1]]] = head if repo['last_revision'] else None
- repo['last_revision'] = revs[-1]
-
- # Now construct the final merge commit. We create the tree by
- # starting with the head and applying the changes from each
- # components imported head revision.
- if additional_heads:
- runcmd("git reset --hard", **wargs)
- for rev, base in additional_heads.items():
- apply_commit(base, rev, wargs, wargs, None)
-
- # Commit with all component branches as parents as well as the previous head.
- logger.info("Writing final merge commit...")
- msg = conf_commit_msg(conf, components)
- new_tree = runcmd("git write-tree", **wargs).strip()
- new_rev = runcmd("git commit-tree".split() +
- add_p([head] + list(additional_heads.keys())) +
- ["-m", msg, new_tree],
- **wargs).strip()
- # And done! This is the first time we change the HEAD in the actual work tree.
- runcmd("git reset --hard %s" % new_rev)
-
- # Update and stage the (potentially modified)
- # combo-layer.conf, but do not commit separately.
- for name in repos:
- repo = conf.repos[name]
- rev = repo['last_revision']
- conf.update(name, "last_revision", rev)
- if commit_conf_file(conf, components, False):
- # Must augment the previous commit.
- runcmd("git commit --amend -C HEAD")
-
-
-scanned_revs = False
-def find_revs(old2new, head):
- '''Construct mapping from original commit hash to commit hash in
- combined repo by looking at the commit messages. Depends on the
- "From ... rev: ..." convention.'''
- logger.info("Analyzing log messages to find previously imported commits...")
- num_known = len(old2new)
- log = runcmd("git log --grep='From .* rev: [a-fA-F0-9][a-fA-F0-9]*' --pretty=format:%H%x00%B%x00 " + head).split(chr(0))
- regex = re.compile(r'From .* rev: ([a-fA-F0-9]+)')
- for new_rev, body in zip(*[iter(log)]* 2):
- # Use the last one, in the unlikely case there are more than one.
- rev = regex.findall(body)[-1]
- if rev not in old2new:
- old2new[rev] = new_rev.strip()
- logger.info("Found %d additional commits, leading to: %s" % (len(old2new) - num_known, old2new))
-
-
-def apply_commit(parent, rev, largs, wargs, dest_dir, file_filter=None):
- '''Compare revision against parent, remove files deleted in the
- commit, re-write new or modified ones. Moves them into dest_dir.
- Optionally filters files.
- '''
- if not dest_dir:
- dest_dir = "."
- # -r recurses into sub-directories, given is the full overview of
- # what changed. We do not care about copy/edits or renames, so we
- # can disable those with --no-renames (but we still parse them,
- # because it was not clear from git documentation whether C and M
- # lines can still occur).
- logger.debug("Applying changes between %s and %s in %s" % (parent, rev, largs["destdir"]))
- delete = []
- update = []
- if parent:
- # Apply delta.
- changes = runcmd("git diff-tree --no-commit-id --no-renames --name-status -r --raw -z %s %s" % (parent, rev), **largs).split(chr(0))
- for status, name in zip(*[iter(changes)]*2):
- if status[0] in "ACMRT":
- update.append(name)
- elif status[0] in "D":
- delete.append(name)
- else:
- logger.error("Unknown status %s of file %s in revision %s" % (status, name, rev))
- sys.exit(1)
- else:
- # Copy all files.
- update.extend(runcmd("git ls-tree -r --name-only -z %s" % rev, **largs).split(chr(0)))
-
- # Include/exclude files as define in the component config.
- # Both updated and deleted file lists get filtered, because it might happen
- # that a file gets excluded, pulled from a different component, and then the
- # excluded file gets deleted. In that case we must keep the copy.
- if file_filter:
- file_filter(update)
- file_filter(delete)
-
- # We export into a tar archive here and extract with tar because it is simple (no
- # need to implement file and symlink writing ourselves) and gives us some degree
- # of parallel IO. The downside is that we have to pass the list of files via
- # command line parameters - hopefully there will never be too many at once.
- if update:
- target = os.path.join(wargs["destdir"], dest_dir)
- if not os.path.isdir(target):
- os.makedirs(target)
- quoted_target = shlex.quote(target)
- # os.sysconf('SC_ARG_MAX') is lying: running a command with
- # string length 629343 already failed with "Argument list too
- # long" although SC_ARG_MAX = 2097152. "man execve" explains
- # the limitations, but those are pretty complicated. So here
- # we just hard-code a fixed value which is more likely to work.
- max_cmdsize = 64 * 1024
- while update:
- quoted_args = []
- unquoted_args = []
- cmdsize = 100 + len(quoted_target)
- while update:
- quoted_next = shlex.quote(update[0])
- size_next = len(quoted_next) + len(dest_dir) + 1
- logger.debug('cmdline length %d + %d < %d?' % (cmdsize, size_next, os.sysconf('SC_ARG_MAX')))
- if cmdsize + size_next < max_cmdsize:
- quoted_args.append(quoted_next)
- unquoted_args.append(update.pop(0))
- cmdsize += size_next
- else:
- logger.debug('Breaking the cmdline at length %d' % cmdsize)
- break
- logger.debug('Final cmdline length %d / %d' % (cmdsize, os.sysconf('SC_ARG_MAX')))
- cmd = "git archive %s %s | tar -C %s -xf -" % (rev, ' '.join(quoted_args), quoted_target)
- logger.debug('First cmdline length %d' % len(cmd))
- runcmd(cmd, **largs)
- cmd = "git add -f".split() + [os.path.join(dest_dir, x) for x in unquoted_args]
- logger.debug('Second cmdline length %d' % reduce(lambda x, y: x + len(y), cmd, 0))
- runcmd(cmd, **wargs)
- if delete:
- for path in delete:
- if dest_dir:
- path = os.path.join(dest_dir, path)
- runcmd("git rm -f --ignore-unmatch".split() + [os.path.join(dest_dir, x) for x in delete], **wargs)
-
-def action_error(conf, args):
- logger.info("invalid action %s" % args[0])
-
-actions = {
- "init": action_init,
- "update": action_update,
- "pull": action_pull,
- "splitpatch": action_splitpatch,
- "sync-revs": action_sync_revs,
-}
-
-def main():
- parser = optparse.OptionParser(
- version = "Combo Layer Repo Tool version %s" % __version__,
- usage = """%prog [options] action
-
-Create and update a combination layer repository from multiple component repositories.
-
-Action:
- init initialise the combo layer repo
- update [components] get patches from component repos and apply them to the combo repo
- pull [components] just pull component repos only
- sync-revs [components] update the config file's last_revision for each repository
- splitpatch [commit] generate commit patch and split per component, default commit is HEAD""")
-
- parser.add_option("-c", "--conf", help = "specify the config file (conf/combo-layer.conf is the default).",
- action = "store", dest = "conffile", default = "conf/combo-layer.conf")
-
- parser.add_option("-i", "--interactive", help = "interactive mode, user can edit the patch list and patches",
- action = "store_true", dest = "interactive", default = False)
-
- parser.add_option("-D", "--debug", help = "output debug information",
- action = "store_true", dest = "debug", default = False)
-
- parser.add_option("-n", "--no-pull", help = "skip pulling component repos during update",
- action = "store_true", dest = "nopull", default = False)
-
- parser.add_option("--hard-reset",
- help = "instead of pull do fetch and hard-reset in component repos",
- action = "store_true", dest = "hard_reset", default = False)
-
- parser.add_option("-H", "--history", help = "import full history of components during init",
- action = "store_true", default = False)
-
- options, args = parser.parse_args(sys.argv)
-
- # Dispatch to action handler
- if len(args) == 1:
- logger.error("No action specified, exiting")
- parser.print_help()
- elif args[1] not in actions:
- logger.error("Unsupported action %s, exiting\n" % (args[1]))
- parser.print_help()
- elif not os.path.exists(options.conffile):
- logger.error("No valid config file, exiting\n")
- parser.print_help()
- else:
- if options.debug:
- logger.setLevel(logging.DEBUG)
- confdata = Configuration(options)
- initmode = (args[1] == 'init')
- confdata.sanity_check(initmode)
- actions.get(args[1], action_error)(confdata, args[1:])
-
-if __name__ == "__main__":
- try:
- ret = main()
- except Exception:
- ret = 1
- import traceback
- traceback.print_exc()
- sys.exit(ret)
deleted file mode 100755
@@ -1,25 +0,0 @@
-#!/bin/sh
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-# Hook to add source component/revision info to commit message
-# Parameter:
-# $1 patch-file
-# $2 revision
-# $3 reponame
-
-patchfile=$1
-rev=$2
-reponame=$3
-
-sed -i -e "0,/^Subject:/s#^Subject: \[PATCH\] \($reponame: \)*\(.*\)#Subject: \[PATCH\] $reponame: \2#" $patchfile
-if grep -q '^Signed-off-by:' $patchfile; then
- # Insert before Signed-off-by.
- sed -i -e "0,/^Signed-off-by:/s#\(^Signed-off-by:.*\)#\(From $reponame rev: $rev\)\n\n\1#" $patchfile
-else
- # Insert before final --- separator, with extra blank lines removed.
- perl -e "\$_ = join('', <>); s/^(.*\S[ \t]*)(\n|\n\s*\n)---\n/\$1\n\nFrom $reponame rev: $rev\n---\n/s; print;" $patchfile >$patchfile.tmp
- mv $patchfile.tmp $patchfile
-fi
deleted file mode 100644
@@ -1,93 +0,0 @@
-# combo-layer example configuration file
-
-# Default values for all sections.
-[DEFAULT]
-
-# Add 'Signed-off-by' to all commits that get imported automatically.
-signoff = True
-
-# component name
-[bitbake]
-
-# Override signedoff default above (not very useful, but possible).
-signoff = False
-
-# mandatory options
-# git upstream uri
-src_uri = git://git.openembedded.org/bitbake
-
-# the directory to clone the component repo
-local_repo_dir = /home/kyu3/src/test/bitbake
-
-# the relative dir within the combo repo to put the component files
-# use "." if the files should be in the root dir
-dest_dir = bitbake
-
-# the last update revision.
-# "init" will set this to the latest revision automatically, however if it
-# is empty when "update" is run, the tool will start from the first commit.
-# Note that this value will get updated by "update" if the component repo's
-# latest revision changed and the operation completes successfully.
-last_revision =
-
-# optional options:
-
-# branch: specify the branch in the component repo to pull from
-# (master if not specified)
-
-# file_filter: only include the specified file(s)
-# file_filter = [path] [path] ...
-# example:
-# file_filter = src/ : only include the subdir src
-# file_filter = src/*.c : only include the src *.c file
-# file_filter = src/main.c src/Makefile.am : only include these two files
-
-# file_exclude: filter out these file(s)
-# file_exclude = [path] [path] ...
-#
-# Each entry must match a file name. In contrast do file_filter, matching
-# a directory has no effect. To achieve that, use append a * wildcard
-# at the end.
-#
-# Wildcards are applied to the complete path and also match slashes.
-#
-# example:
-# file_exclude = src/foobar/* : exclude everything under src/foobar
-# file_exclude = src/main.c : filter out main.c after including it with file_filter = src/*.c
-# file_exclude = *~ : exclude backup files
-
-# hook: if provided, the tool will call the hook to process the generated
-# patch from upstream, and then apply the modified patch to the combo
-# repo.
-# the hook script is called as follows: ./hook patchpath revision reponame
-# example:
-# hook = combo-layer-hook-default.sh
-
-# since_revision:
-# since_revision = release-1-2
-# since_revision = 12345 abcdf
-#
-# If provided, truncate imported history during "combo-layer --history
-# init" at the specified revision(s). More than one can be specified
-# to cut off multiple component branches.
-#
-# The specified commits themselves do not get imported. Instead, an
-# artificial commit with "unknown" author is created with a content
-# that matches the original commit.
-
-[oe-core]
-src_uri = git://git.openembedded.org/openembedded-core
-local_repo_dir = /home/kyu3/src/test/oecore
-dest_dir = .
-last_revision =
-since_revision = some-tag-or-commit-on-master-branch
-
-# It is also possible to embed python code in the config values. Similar
-# to bitbake it considers every value starting with @ to be a python
-# script.
-# e.g. local_repo_dir could easily be configured using an environment
-# variable:
-#
-# [bitbake]
-# local_repo_dir = @os.getenv("LOCAL_REPO_DIR") + "/bitbake"
-#
The combo-layer script has not been used with master of OE-Core since the poky repository stopped being updated. Signed-off-by: Peter Kjellerstedt <peter.kjellerstedt@axis.com> --- scripts/combo-layer | 1384 --------------------------- scripts/combo-layer-hook-default.sh | 25 - scripts/combo-layer.conf.example | 93 -- 3 files changed, 1502 deletions(-) delete mode 100755 scripts/combo-layer delete mode 100755 scripts/combo-layer-hook-default.sh delete mode 100644 scripts/combo-layer.conf.example