def main(argv):
retval = 0
(options, args) = parse_args(argv)
if not options:
return 1
if len(args) < 2:
gbp.log.err("Need a repository to clone.")
return 1
else:
source = args[1]
clone_to, auto_name = (os.path.curdir, True) if len(args) < 3 else (args[2], False)
try:
GitRepository(clone_to)
gbp.log.err("Can't run inside a git repository.")
return 1
except GitRepositoryError:
pass
try:
repo = DebianGitRepository.clone(clone_to, source, options.depth,
auto_name=auto_name)
os.chdir(repo.path)
# Reparse the config files of the cloned repository so we pick up the
# branch information from there:
(options, args) = parse_args(argv)
# Track all branches:
if options.all:
remotes = repo.get_remote_branches()
for remote in remotes:
local = remote.replace("origin/", "", 1)
if not repo.has_branch(local) and \
local != "HEAD":
repo.create_branch(local, remote)
else: # only track gbp's default branches
branches = [ options.debian_branch, options.upstream_branch ]
if options.pristine_tar:
branches += [ repo.pristine_tar_branch ]
gbp.log.debug('Will track branches: %s' % branches)
for branch in branches:
remote = 'origin/%s' % branch
if repo.has_branch(remote, remote=True) and \
not repo.has_branch(branch):
repo.create_branch(branch, remote)
repo.set_branch(options.debian_branch)
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
return retval
def test_tagging_native(self):
"""Test tagging of native packages with import-srpm"""
srpm = os.path.join(DATA_DIR, 'gbp-test-native-1.0-1.src.rpm')
# Invalid packaging tag keywords
eq_(
mock_import([
'--no-pristine-tar', '--packaging-tag=%(foo)s', srpm,
'--native'
]), 1)
self._check_log(-1, ".*Missing value 'foo' in {.*")
# Try with good keywords, with --skip-packaging-tag.
# Upstream tag format should not matter
eq_(
mock_import([
'--no-pristine-tar', '--vendor=foo', '--native',
'--skip-packaging-tag',
'--packaging-tag=%(vendor)s/%(version)s',
'--upstream-tag=%(foo)s', srpm
]), 0)
repo = GitRepository('gbp-test-native')
eq_(len(repo.get_tags()), 0)
# Run again, now creating packaging tag
eq_(
mock_import([
'--no-pristine-tar', '--vendor=foo', '--native',
'--packaging-tag=%(vendor)s/%(version)s',
'--upstream-tag=%(foo)s', srpm
]), 0)
eq_(repo.describe('HEAD'), 'foo/1.0-1')
def parse_config_files(self):
"""
Parse the possible config files and set appropriate values
default values
"""
parser = configparser.SafeConfigParser()
# Fill in the built in values
self.config = dict(self.__class__.defaults)
# Update with the values from the defaults section. This is needed
# in case the config file doesn't have a [<command>] section at all
config_files = self.get_config_files()
try:
repo = GitRepository(".")
except GitRepositoryError:
repo = None
# Read all config files
for filename in config_files:
self._read_config_file(parser, repo, filename)
self.config.update(dict(parser.defaults()))
# Make sure we read any legacy sections prior to the real subcommands
# section i.e. read [gbp-pull] prior to [pull]
if (self.command.startswith('gbp-')
or self.command.startswith('git-')):
cmd = self.command[4:]
oldcmd = self.command
if parser.has_section(oldcmd):
self.config.update(dict(parser.items(oldcmd, raw=True)))
gbp.log.warn("Old style config section [%s] found "
"please rename to [%s]" % (oldcmd, cmd))
else:
cmd = self.command
for prefix in ['gbp', 'git']:
oldcmd = '%s-%s' % (prefix, self.command)
if parser.has_section(oldcmd):
self.config.update(dict(parser.items(oldcmd, raw=True)))
gbp.log.warn("Old style config section [%s] found "
"please rename to [%s]" % (oldcmd, cmd))
# Update with command specific settings
if parser.has_section(cmd):
# Don't use items() until we got rid of the compat sections
# since this pulls in the defaults again
self.config.update(dict(parser._sections[cmd].items()))
for section in self.sections:
if parser.has_section(section):
self.config.update(dict(parser._sections[section].items()))
else:
raise configparser.NoSectionError(
"Mandatory section [%s] does not exist." % section)
# filter can be either a list or a string, always build a list:
if self.config['filter']:
if self.config['filter'].startswith('['):
self.config['filter'] = eval(self.config['filter'])
else:
self.config['filter'] = [self.config['filter']]
else:
self.config['filter'] = []
def test_misc_options(self):
"""Test various options of git-import-srpm"""
srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm')
eq_(
mock_import([
'--no-patch-import', '--packaging-branch=pack',
'--upstream-branch=orig', '--packaging-dir=packaging',
'--packaging-tag=ver_%(upstreamversion)s-rel_%(release)s',
'--upstream-tag=orig/%(upstreamversion)s',
'--author-is-committer', srpm
]), 0)
# Check repository state
repo = GitRepository('gbp-test2')
files = set([
'Makefile', 'README', 'dummy.sh', 'packaging/bar.tar.gz',
'packaging/foo.txt', 'packaging/gbp-test2.spec',
'packaging/gbp-test2-alt.spec', 'packaging/my.patch',
'packaging/my2.patch', 'packaging/my3.patch'
])
self._check_repo_state(repo, 'pack', ['pack', 'orig'], files)
eq_(len(repo.get_commits()), 2)
# Check packaging dir
eq_(len(repo.get_commits(paths='packaging')), 1)
# Check tags
tags = repo.get_tags()
eq_(set(tags), set(['orig/2.0', 'ver_2.0-rel_0']))
# Check git committer/author
info = repo.get_commit_info('pack')
eq_(info['author'].name, 'Markus Lehtonen')
eq_(info['author'].email, '*****@*****.**')
eq_(info['author'].name, info['committer'].name)
eq_(info['author'].email, info['committer'].email)
def test_multiple_versions(self):
"""Test importing of multiple versions"""
srpms = [
os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm'),
os.path.join(DATA_DIR, 'gbp-test-1.0-1.other.src.rpm'),
os.path.join(DATA_DIR, 'gbp-test-1.1-1.src.rpm')
]
eq_(mock_import(['--no-pristine-tar', srpms[0]]), 0)
repo = GitRepository('gbp-test')
self._check_repo_state(repo, 'master', ['master', 'upstream'])
eq_(len(repo.get_commits()), 4)
# Try to import same version again
eq_(mock_import([srpms[1]]), 0)
eq_(len(repo.get_commits()), 4)
eq_(len(repo.get_commits(until='upstream')), 1)
eq_(mock_import(['--allow-same-version', srpms[1]]), 0)
# Added new versio packaging plus one patch
eq_(len(repo.get_commits()), 7)
eq_(len(repo.get_commits(until='upstream')), 1)
# Import new version
eq_(mock_import([srpms[2]]), 0)
files = set([
'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt',
'gbp-test.spec', 'my.patch', 'mydir/myfile.txt'
])
self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
eq_(len(repo.get_commits()), 11)
eq_(len(repo.get_commits(until='upstream')), 2)
# Check number of tags
eq_(len(repo.get_tags('upstream/*')), 2)
eq_(len(repo.get_tags('vendor/*')), 3)
def test_target_dir(self):
"""Test importing to target dir"""
srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm')
eq_(mock_import(['--no-pristine-tar', srpm, 'targetdir']), 0)
# Check repository state
assert os.path.exists('targetdir')
repo = GitRepository('targetdir')
self._check_repo_state(repo, 'master', ['master', 'upstream'])
def test_filter(self):
"""Test filter option"""
srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm')
eq_(mock_import(['--no-pristine-tar', '--filter=README', '--filter=mydir', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test')
files = set(['Makefile', 'dummy.sh', 'bar.tar.gz', 'foo.txt',
'gbp-test.spec', 'my.patch', 'my2.patch', 'my3.patch'])
self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
def test_unsupported_archive(self):
"""Test importing of src.rpm with a zip source archive"""
srpm = os.path.join(DATA_DIR, 'gbp-test-native-1.0-1.src.rpm')
eq_(mock_import(['--pristine-tar', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test-native')
self._check_repo_state(repo, 'master', ['master', 'upstream'])
# Check that a warning is printed
self._check_log(-1, "gbp:warning: Ignoring pristine-tar")
def test_import_no_orig_src(self):
"""Test importing of (native) srpm without orig tarball"""
srpm = os.path.join(DATA_DIR, 'gbp-test-native2-2.0-0.src.rpm')
eq_(mock_import([srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test-native2')
self._check_repo_state(repo, 'master', ['master'])
# Only one commit: packaging files
eq_(len(repo.get_commits()), 1)
def test_basic_import_pristine_tar(self):
"""Test importing of non-native src.rpm, with pristine-tar"""
srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm')
eq_(mock_import(['--pristine-tar', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test')
self._check_repo_state(repo, 'master', ['master', 'upstream',
'pristine-tar'])
# Two commits: upstream and packaging files
eq_(len(repo.get_commits()), 2)
def test_basic_import(self):
"""Test importing of non-native src.rpm"""
srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm')
eq_(mock_import(['--no-pristine-tar', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test')
files = {'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt',
'gbp-test.spec', 'my.patch', 'my2.patch', 'my3.patch'}
self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
# Two commits: upstream and packaging files
eq_(len(repo.get_commits()), 2)
def test_basic_native_import(self):
"""Test importing of native src.rpm"""
srpm = os.path.join(DATA_DIR, 'gbp-test-native-1.0-1.src.rpm')
eq_(mock_import(['--native', srpm]), 0)
# Check repository state
files = {'.gbp.conf', 'Makefile', 'README', 'dummy.sh',
'packaging/gbp-test-native.spec'}
repo = GitRepository('gbp-test-native')
self._check_repo_state(repo, 'master', ['master'], files)
# Only one commit: the imported source tarball
eq_(len(repo.get_commits()), 1)
def test_import_dir(self):
"""Test importing of directories"""
eq_(mock_import(['--no-pristine-tar', 'gbp-test-1.0-1-unpack']), 0)
# Check repository state
repo = GitRepository('gbp-test')
self._check_repo_state(repo, 'master', ['master', 'upstream'])
# Check that importing dir with multiple spec files fails
eq_(mock_import(['multi-unpack']), 1)
self._check_log(-1, 'gbp:error: Failed determine spec file: '
'Multiple spec files found')
def test_misc_options(self):
"""Test various options of git-import-srpm"""
srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm')
eq_(
mock_import([
'--no-pristine-tar', '--packaging-branch=pack',
'--upstream-branch=orig', '--packaging-dir=packaging',
'--packaging-tag=ver_%(upstreamversion)s-rel_%(release)s',
'--upstream-tag=orig/%(upstreamversion)s',
'--author-is-committer', srpm
]), 0)
# Check repository state
repo = GitRepository('gbp-test2')
files = {
'Makefile', 'README', 'dummy.sh', 'packaging/bar.tar.gz',
'packaging/foo.txt', 'packaging/gbp-test2.spec',
'packaging/gbp-test2-alt.spec', 'packaging/my.patch',
'packaging/my2.patch', 'packaging/my3.patch'
}
self._check_repo_state(repo, 'pack', ['pack', 'orig'], files)
eq_(len(repo.get_commits()), 2)
# Check packaging dir
eq_(len(repo.get_commits(paths='packaging')), 1)
# Check tags
tags = repo.get_tags()
eq_(set(tags), set(['orig/2.0', 'ver_2.0-rel_0']))
# Check git committer/author
info = repo.get_commit_info('pack')
eq_(info['author'].name, 'Markus Lehtonen')
eq_(info['author'].email, '*****@*****.**')
eq_(info['author'].name, info['committer'].name)
eq_(info['author'].email, info['committer'].email)
# Create a new commit by committing an empty tree
commit = repo.commit_tree('4b825dc642cb6eb9a060e54bf8d69288fbee4904',
msg="Empty commit",
parents=[])
repo.create_tag('foo/1.0', msg="New tag", commit=commit)
# Just blindly import another package on top of this to test more options
os.chdir('gbp-test2')
srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm')
eq_(
mock_import([
'--upstream-vcs-tag=foo/%(version)s', '--upstream-branch=orig',
'--packaging-branch=pack', srpm
]), 0)
parents = repo.get_commits(until='orig', num=1,
options='--format=%P')[0].split()
eq_(len(parents), 2)
ok_(commit in parents)
ok_(repo.rev_parse('orig/2.0^{}') in parents)
def test_urldownload(self):
"""Test downloading and importing src.rpm from remote url"""
srpm = 'http://raw.github.com/marquiz/git-buildpackage-rpm-testdata/'\
'master/gbp-test-1.0-1.src.rpm'
# Mock to use local files instead of really downloading
local_fn = os.path.join(DATA_DIR, os.path.basename(srpm))
urllib2.urlopen = Mock()
urllib2.urlopen.return_value = open(local_fn, 'r')
eq_(mock_import(['--no-pristine-tar', '--download', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test')
self._check_repo_state(repo, 'master', ['master', 'upstream'])
def test_basic_import2(self):
"""Import package with multiple spec files and full url patch"""
srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm')
eq_(mock_import(['--no-pristine-tar', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test2')
files = {'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt',
'gbp-test2.spec', 'gbp-test2-alt.spec', 'my.patch',
'my2.patch', 'my3.patch'}
self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
# Two commits: upstream and packaging files
eq_(len(repo.get_commits()), 2)
def parse_config_files(self):
"""
Parse the possible config files and set appropriate values
default values
"""
parser = self.config_parser
# Fill in the built in values
self.config = dict(self.__class__.defaults)
config_files = self.get_config_files()
try:
repo = GitRepository(".", toplevel=False)
except GitRepositoryError:
repo = None
# Read all config files
for filename in config_files:
self._read_config_file(repo, filename)
# Update with the values from the defaults section. This is needed
# in case the config file doesn't have a [<command>] section at all
self.config.update(dict(parser.defaults()))
# Make sure we read any legacy sections prior to the real subcommands
# section i.e. read [gbp-pull] prior to [pull]
if (self.command.startswith('gbp-')
or self.command.startswith('git-')):
cmd = self.command[4:]
oldcmd = self.command
if parser.has_section(oldcmd):
self.config.update(dict(parser.items(oldcmd, raw=True)))
self._warn_old_config_section(oldcmd, cmd)
else:
cmd = self.command
for prefix in ['gbp', 'git']:
oldcmd = '%s-%s' % (prefix, self.command)
if parser.has_section(oldcmd):
self.config.update(dict(parser.items(oldcmd, raw=True)))
self._warn_old_config_section(oldcmd, cmd)
# Update with command specific settings
if parser.has_section(cmd):
# Don't use items() until we got rid of the compat sections
# since this pulls in the defaults again
self.config.update(dict(parser._sections[cmd].items()))
for section in self.sections:
if parser.has_section(section):
self.config.update(dict(parser._sections[section].items()))
else:
raise configparser.NoSectionError(
"Mandatory section [%s] does not exist." % section)
self.parse_lists()
def test_import_compressed_patches(self):
"""Test importing of non-native src.rpm with compressed patches"""
srpm = os.path.join(DATA_DIR, 'gbp-test-1.1-2.src.rpm')
eq_(mock_import([srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test')
files = set([
'Makefile', 'README', 'AUTHORS', 'NEWS', 'bar.tar.gz', 'dummy.sh',
'foo.txt', 'gbp-test.spec', 'my.patch', 'mydir/myfile.txt'
])
self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
# Four commits: upstream, packaging files, three patches and the removal
# of imported patches
eq_(len(repo.get_commits()), 6)
def test_basic_import(self):
"""Test importing of non-native src.rpm"""
srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm')
eq_(mock_import(['--no-pristine-tar', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test')
files = set([
'Makefile', 'README', 'bar.tar.gz', 'dummy.sh', 'foo.txt',
'gbp-test.spec', 'my.patch', 'mydir/myfile.txt'
])
self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
# Four commits: upstream, packaging files, one patch and the removal
# of imported patches
eq_(len(repo.get_commits()), 4)
def test_basic_import_orphan(self):
"""
Test importing of non-native src.rpm to separate packaging and
development branches
"""
srpm = os.path.join(DATA_DIR, 'gbp-test2-2.0-0.src.rpm')
eq_(mock_import(['--no-pristine-tar', '--orphan-packaging', srpm]), 0)
# Check repository state
repo = GitRepository('gbp-test2')
files = {'bar.tar.gz', 'foo.txt', 'gbp-test2.spec',
'gbp-test2-alt.spec', 'my.patch', 'my2.patch', 'my3.patch'}
self._check_repo_state(repo, 'master', ['master', 'upstream'], files)
# Only one commit: the packaging files
eq_(len(repo.get_commits()), 1)
def main(argv):
"""Entry point for gbp-submit-bb"""
retval = 0
options, _args = parse_args(argv)
if not options:
return 1
try:
repo = GitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("The command must be run under a Git repository")
return 1
try:
remote = guess_remote(repo, options)
tag_fields = {
'nowtime': datetime.now().strftime('%Y%m%d.%H%M%S'),
'target': options.target
}
tag_name = format_msg(options.submit_tag, tag_fields)
gbp.log.info("Tagging %s" % tag_name)
repo.create_tag(tag_name,
msg=options.message,
commit=options.commit,
sign=options.sign_tags,
keyid=options.keyid,
annotate=True)
gbp.log.info("Pushing to remote %s" % remote)
try:
repo.push_tag(remote, tag_name)
except GitRepositoryError as err:
gbp.log.err(err)
gbp.log.info("Removing tag %s" % tag_name)
repo.delete_tag(tag_name)
raise GbpError("Git push failed!")
except (GbpError, GitRepositoryError) as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
return retval
def test_tagging(self):
"""Test tag options of import-srpm"""
srpm = os.path.join(DATA_DIR, 'gbp-test-1.0-1.src.rpm')
# Invalid packaging tag keywords
eq_(
mock_import(['--no-pristine-tar', '--packaging-tag=%(foo)s',
srpm]), 1)
self._check_log(-1, ".*Missing value 'foo' in *.*")
# Remove upstream tag
repo = GitRepository('gbp-test')
repo.delete_tag('upstream/1.0')
# Invalid upstream tag keywords
eq_(mock_import(['--no-pristine-tar', '--upstream-tag=%(foo)s', srpm]),
1)
self._check_log(-1, ".*Missing value 'foo' in.*")
# Try with good keywords, with --skip-packaging-tag
eq_(
mock_import([
'--no-pristine-tar', '--vendor=foo', '--skip-packaging-tag',
'--packaging-tag=%(vendor)s/%(version)s',
'--upstream-tag=upst/%(version)s', srpm
]), 0)
eq_(repo.describe('upstream'), 'upst/1.0')
eq_(len(repo.get_tags()), 1)
# Re-import, creating packaging tag
eq_(
mock_import([
'--no-pristine-tar', '--vendor=foo',
'--packaging-tag=%(vendor)s/%(version)s',
'--upstream-tag=upst/%(version)s', srpm
]), 0)
eq_(repo.describe('HEAD'), 'foo/1.0-1')
eq_(len(repo.get_tags()), 2)
def main(argv):
retval = 0
(options, args) = parse_args(argv)
if not options:
return 1
gbp.log.setup(options.color, options.verbose, options.color_scheme)
if len(args) < 2:
gbp.log.err("No action given.")
return 1
else:
action = args[1]
if args[1] in ["export", "import", "rebase", "drop", "switch"]:
pass
elif args[1] in ["apply"]:
if len(args) != 3:
gbp.log.err("No patch name given.")
return 1
else:
patchfile = args[2]
else:
gbp.log.err("Unknown action '%s'." % args[1])
return 1
try:
repo = GitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
current = repo.get_branch()
if action == "export":
export_patches(repo, current, options)
elif action == "import":
series = SERIES_FILE
tries = options.time_machine if (options.time_machine > 0) else 1
import_quilt_patches(repo, current, series, tries, options.force)
current = repo.get_branch()
gbp.log.info("Patches listed in '%s' imported on '%s'" %
(series, current))
elif action == "drop":
drop_pq(repo, current)
elif action == "rebase":
rebase_pq(repo, current)
elif action == "apply":
patch = Patch(patchfile)
maintainer = get_maintainer_from_control(repo)
apply_single_patch(repo, current, patch, maintainer, options.topic)
elif action == "switch":
switch_pq(repo, current)
except CommandExecFailed:
retval = 1
except (GbpError, GitRepositoryError) as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
return retval
sys.exit(1)
if verbose: print "Processing packages: %s" % packages_to_process
else:
print "Unknown argument (%s)!" % o
sys.exit(1)
# Check to make sure an operation was specified
if len(op) == 0:
print "An operation must be specified!"
print "Please use one of:",
for o in ops:
print o,
sys.exit(1)
# Instantiate a git-buildpackage repository object
gbp_repo = GitRepository(os.getcwd())
# Set up our branch and tag nomenclature
upstream_branch = 'upstream'
debian_branch = 'master'
upstream_tag = 'upstream'
debian_tag = 'debian'
# Now do the actual work
if op == 'import':
# Make sure the user specified the location of the tarball
if len(import_tarball) == 0:
print "Please specify the -n option for the import operation!"
sys.exit(1)
# Make sure we have read access to the file
def main(argv):
retval = 0
(options, args) = parse_args(argv)
if not options:
return ExitCodes.parse_error
if len(args) < 2:
gbp.log.err("Need a repository to clone.")
return 1
else:
source = args[1]
clone_to, auto_name = (os.path.curdir,
True) if len(args) < 3 else (args[2], False)
try:
GitRepository(clone_to)
gbp.log.err("Can't run inside a git repository.")
return 1
except GitRepositoryError:
pass
try:
gbp.log.info(
"Cloning from '%s'%s" %
(source, " into '%s'" % clone_to if not auto_name else ''))
repo = DebianGitRepository.clone(clone_to,
source,
options.depth,
auto_name=auto_name,
reference=options.reference)
os.chdir(repo.path)
# Reparse the config files of the cloned repository so we pick up the
# branch information from there but don't overwrite hooks:
postclone = options.postclone
(options, args) = parse_args(argv)
# Track all branches:
if options.all:
remotes = repo.get_remote_branches()
for remote in remotes:
local = remote.replace("origin/", "", 1)
if (not repo.has_branch(local) and local != "HEAD"):
repo.create_branch(local, remote)
else: # only track gbp's default branches
branches = [options.debian_branch, options.upstream_branch]
if options.pristine_tar:
branches += [repo.pristine_tar_branch]
gbp.log.debug('Will track branches: %s' % branches)
for branch in branches:
remote = 'origin/%s' % branch
if (repo.has_branch(remote, remote=True)
and not repo.has_branch(branch)):
repo.create_branch(branch, remote)
repo.set_branch(options.debian_branch)
repo_setup.set_user_name_and_email(options.repo_user,
options.repo_email, repo)
if postclone:
Hook(
'Postclone',
options.postclone,
extra_env={'GBP_GIT_DIR': repo.git_dir},
)()
except KeyboardInterrupt:
retval = 1
gbp.log.err("Interrupted. Aborting.")
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
except GbpError as err:
if str(err):
gbp.log.err(err)
retval = 1
return retval
def main(argv):
dirs = dict(top=os.path.abspath(os.curdir))
dscs = []
ret = 0
verbose = False
dsc_key = cmp_to_key(DscCompareVersions())
use_debsnap = False
try:
import_args = argv[1:]
if '--verbose' in import_args:
verbose = True
gbp.log.setup(False, verbose)
if '--ignore-repo-config' in import_args:
set_gbp_conf_files()
import_args.remove('--ignore-repo-config')
# Not using Configparser since we want to pass all unknown options
# unaltered to gbp import-dsc
if '--debsnap' in import_args:
use_debsnap = True
import_args.remove('--debsnap')
if import_args == []:
print_help()
raise GbpError
pkg = import_args[-1]
import_args = import_args[:-1]
else:
for arg in argv[::-1]:
if arg.endswith('.dsc'):
dscs.append(DscFile.parse(arg))
import_args.remove(arg)
if not use_debsnap and not dscs:
print_help()
raise GbpError
if use_debsnap:
dirs['tmp'] = os.path.abspath(tempfile.mkdtemp())
dscs = [
DscFile.parse(f) for f in fetch_snapshots(pkg, dirs['tmp'])
]
dscs.sort(key=dsc_key)
importer = GitImportDsc(import_args)
try:
repo = GitRepository('.')
(clean, out) = repo.is_clean()
if not clean:
gbp.log.err("Repository has uncommitted changes, "
"commit these first: ")
raise GbpError(out)
else:
dirs['pkg'] = dirs['top']
except GitRepositoryError:
# no git repository there yet
dirs['pkg'] = os.path.join(dirs['top'], dscs[0].pkg)
if importer.importdsc(dscs[0]):
raise GbpError("Failed to import '%s'" % dscs[0].dscfile)
os.chdir(dirs['pkg'])
for dsc in dscs[1:]:
if importer.importdsc(dsc):
raise GbpError("Failed to import '%s'" % dscs[0].dscfile)
except KeyboardInterrupt:
ret = 1
gbp.log.err("Interrupted. Aborting.")
except (GbpError, gbpc.CommandExecFailed, GitRepositoryError) as err:
if str(err):
gbp.log.err(err)
ret = 1
finally:
if 'tmp' in dirs:
gbpc.RemoveTree(dirs['tmp'])()
os.chdir(dirs['top'])
if not ret:
gbp.log.info('Everything imported under %s' % dirs['pkg'])
return ret
def init_test_repo(cls, pkg_name):
"""Initialize git repository for testing"""
dirname = os.path.basename(cls.orig_repos[pkg_name].path)
shutil.copytree(cls.orig_repos[pkg_name].path, dirname)
os.chdir(dirname)
return GitRepository('.')
def test_import_spec(self):
"""Test importing of spec file"""
specfile = 'gbp-test2-2.0-0-unpack/gbp-test2.spec'
eq_(mock_import([specfile]), 0)
# Check repository state
ok_(GitRepository('gbp-test2').is_clean())
