def setup_source(self, package):
'''Given a package, set's it up in the buildroot for being built with rpmbuild
package is a directory name to a Package (Directory).
returns nothing
'''
pkg = DirFactory(package)
with pwd(pkg.dir):
symlink(pkg.spec_file,
join(self.dir, 'SPECS', pkg.spec_file))
pkg.fetch_sourceballs()
for source in pkg.spec_all_sources():
log.debug(source)
symlink(source, join(self.dir, 'SOURCES', source))
def build(self, package):
pkg = DirFactory(package)
srpm_name = pkg.get_srpm_name(self.profile)
mock_cfg = self.profile.mock_cfg
result_dir = self.profile.result_dir
config_dir = self.profile.mock_cfg_dir
log.debug("mock_cfg is " + mock_cfg)
log.debug("result_dir is " + result_dir)
log.debug("config_dir is " + config_dir)
cmd = ["mock", "-r", mock_cfg, "--configdir=%s" % config_dir, "--resultdir=%s" % result_dir, srpm_name]
log.debug("cmd is " + str(cmd))
with pwd(result_dir):
with log_file("mock.log") as mock_out:
p = Popen(cmd, stdout=mock_out, stderr=mock_out)
log.info("mock compiling %s... please wait" % srpm_name)
p.communicate()
def move_source(self, source_dir):
source = DirFactory(source_dir)
target_dir = join(self.dir, source.name)
if not source.dir == target_dir:
source.move(target_dir)
self.add_source(source_dir)
def __init__(self, package=None):
if not package:
package = getcwd()
self.pkg = DirFactory(package)
class Port(Module):
def __init__(self, package=None):
if not package:
package = getcwd()
self.pkg = DirFactory(package)
@property
def sourceball(self):
raise NotImplementedError
@property
def revision_control(self):
raise NotImplementedError
@property
def builder(self):
raise NotImplementedError
@property
def fetcher(self):
raise NotImplementedError
def add_sourceball(self, sourceball):
'''copies a tarball into the package
tarball is a path to some tarball
'''
with pwd(self.pkg.dir):
pkg_src = self.sourceball('', sourceball)
pkg_src.set_buildsystem(self.builder._type)
name = pkg_src.name
self.pkg.add_source(name)
return close_later(pkg_src)
def add_vcs(self, url, tgt, *args):
'''creates a darcs variant of a cabal package using darcs source
url is a url to some darcs repo
tgt is the local name of the darcs repo
'''
with pwd(self.pkg.dir):
pkg_src = self.revision_control(tgt, url, *args)
pkg_src.set_buildsystem(self.builder._type)
name = pkg_src.name
self.pkg.add_source(name)
return close_later(pkg_src)
def install_sourceball(self, tarball, target='home', *args):
'''given a tarball, copy it in and install it
'''
pkg_src = self.add_sourceball(tarball)
self.builder(pkg_src).install_source(target, *args)
def add_from_release(self, pkg, ver):
'''get a specific package from hackage
pkg is the name of the package desired
ver is the version wanted
'''
sb_loc = self.fetcher().url(pkg, ver)
sb = self.add_sourceball(sb_loc)
sb.cfg['release_name'] = pkg
return sb
def add_latest(self, pkg):
'''get the latest version of a package from hackage
pkg is the package desired
'''
ver = self.fetcher().latest_version(pkg)
return self.add_from_release(pkg, ver)
def install_from_release(self, pkg, ver, target='home', *args):
'''get and install a specific package from hackage
pkg is the desired package
ver is the version wanted
target is the location to install to, either 'home' or 'root'
'''
sb_loc = self.fetcher().url(pkg, ver)
self.install_sourceball(sb_loc, target, *args)
def install_latest(self, pkg, target='home', *args):
'''get and install the latest version of a package from hackage'''
ver = self.fetcher().latest_version(pkg)
self.install_from_release(pkg, ver, target, *args)
def add_upstream(self, pkg, tgt=None, *args):
if not tgt:
tgt = pkg
return self.add_vcs(self.fetcher().vcs_url(pkg), tgt, *args)
def install_upstream(self, pkg, tgt=None, target='home', *args):
pkg_src = self.add_upstream(pkg, tgt, *args)
self.builder(pkg_src).install_source(target)
def prepare_sourceballs(self, install=False, force=False, *args):
tmp_dir = mkdtemp()
pkg_srcen = self.pkg.sources
pkg_srcen = (DirFactory(pkg_src) for pkg_src in pkg_srcen)
with self.pkg.in_dir():
for pkg_src in pkg_srcen:
with pwd(tmp_dir):
sourceball = SourceBall(pkg_src.full_name, pkg_src.sourceball_loc)
builder = self.builder(sourceball)
builder.prepare(install, force, *args)
rm(sourceball.pkg_src_dir)
tar_file = tarfile.open(pkg_src.sourceball_loc, 'w:gz')
tar_file.add(pkg_src.full_name)
tar_file.close()
rm(tmp_dir)
def build_source_rpm(self, build, profile):
builder = Build(build)
profile = Profile(profile)
builder.setup_source(self.pkg.dir)
self.prepare_sourceballs()
builder.build_source_rpm(self.pkg.dir, profile)
builder.fetch_rpms(profile.result_dir)
def build_binary_rpm(self, build, profile):
mock = Mock(profile, build)
mock.build(self.pkg.dir)
def build_rpm(self, build, profile):
self.build_source_rpm(build, profile)
self.build_binary_rpm(build, profile)
def close(self):
self.pkg.close()
close_all()
