def builder_action_distr_man(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=['mandocs'] + self.custom_data['crossbuild_arch_params'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
if ret == 0:
if not os.path.isdir(self.custom_data['dst_man_dir']):
os.makedirs(self.custom_data['dst_man_dir'])
man_files = glob.glob(
wayround_i2p.utils.path.join(self.get_src_dir(),
'Documentation', 'DocBook', 'man',
'*.9.gz'))
man_files.sort()
log.info("Copying {} man file(s)".format(len(man_files)))
for i in man_files:
base = os.path.basename(i)
log.info("copying {}".format(base))
shutil.copy(
wayround_i2p.utils.path.join(i),
wayround_i2p.utils.path.join(
self.custom_data['dst_man_dir'], base))
return ret
def builder_action_distribute(self, called_as, log):
self.check_deprecated_methods(called_as, log)
envs = {}
if hasattr(self, 'builder_action_distribute_define_environment'):
envs = self.builder_action_distribute_define_environment(
called_as, log)
opts = []
if hasattr(self, 'builder_action_distribute_define_opts'):
opts = self.builder_action_distribute_define_opts(called_as, log)
args = []
if hasattr(self, 'builder_action_distribute_define_args'):
args = self.builder_action_distribute_define_args(called_as, log)
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=opts,
arguments=args,
environment=envs,
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distr_kernel(self, called_as, log):
if not os.path.exists(self.custom_data['dst_boot_dir']):
os.makedirs(self.custom_data['dst_boot_dir'])
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'install', 'INSTALL_PATH=' + self.custom_data['dst_boot_dir']
] + self.custom_data['crossbuild_arch_params'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
if ret == 0:
p1 = wayround_i2p.utils.path.join(self.custom_data['dst_boot_dir'],
'vmlinuz')
p2 = wayround_i2p.utils.path.join(
self.custom_data['dst_boot_dir'], 'vmlinuz-{}-{}'.format(
self.get_package_info()['pkg_nameinfo']['groups']
['version'], self.get_host_from_pkgi()))
log.info("Renaming: `{}' to `{}'".format(p1, p2))
os.rename(p1, p2)
return ret
def builder_action_distribute(self, called_as, log):
doc_dir = wayround_i2p.utils.path.join(
self.calculate_dst_install_prefix(), 'share', 'doc', 'db')
os.makedirs(doc_dir, exist_ok=True)
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'install', 'DESTDIR={}'.format(self.get_dst_dir()),
'docdir={}'.format(
wayround_i2p.utils.path.join(
self.calculate_install_prefix(), 'share', 'doc', 'db'))
# it's not a mistake docdir
# must be eq to self.calculate_install_prefix() + /share/doc/db
# with leading slash
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_build(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[] + self.custom_data['crossbuild_arch_params'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_build_so(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=['SHARED=1'] + self.all_automatic_flags_as_list(),
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_build_02(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=['all-target-libgcc'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=['install', 'INSTROOT={}'.format(self.get_dst_dir())],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distr_firmware(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'firmware_install', 'INSTALL_MOD_PATH=' + self.get_dst_dir()
] + self.custom_data['crossbuild_arch_params'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_build(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'CHAPMS=1', 'USE_CRYPT=1', 'INCLUDE_DIRS+= -I../include '
] + self.all_automatic_flags_as_list(),
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def _builder_action_distr_headers_001(self, called_as, log, h_all=False):
ret = 0
command = 'headers_install'
if h_all:
command = 'headers_install_all'
if self.get_is_only_other_arch():
install_hdr_path = wayround_i2p.utils.path.join(
self.get_dst_dir(), 'usr', 'multiarch',
self.get_arch_from_pkgi())
elif self.get_is_crossbuilder():
install_hdr_path = wayround_i2p.utils.path.join(
self.get_dst_dir(), 'usr', 'crossbuilders',
self.get_target_from_pkgi())
else:
install_hdr_path = wayround_i2p.utils.path.join(
self.get_dst_dir(), 'usr')
if ret == 0:
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[command] +
['INSTALL_HDR_PATH=' + install_hdr_path] +
self.custom_data['crossbuild_arch_params'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
print('-----------------')
print("Now You need to create asm symlink in include dir")
if self.get_is_crossbuilder() or self.get_is_only_other_arch():
print("and pack this building site")
ret = 0
else:
print("and continue with 'distr_man+' action")
ret = 1
print('-----------------')
return ret
def builder_action_distribute_01_2(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
wayround_i2p.utils.path.join('csu', 'subdir_lib')
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.bld_dir,
source_configure_reldir=self.source_configure_reldir
)
return ret
def builder_action_distribute(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'install',
'prefix={}'.format(self.calculate_install_prefix()),
'DESTDIR={}'.format(self.get_dst_dir()),
] + self.all_automatic_flags_as_list(),
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute_01(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'install-bootstrap-headers=yes',
'install-headers',
'DESTDIR=' + self.get_dst_dir()
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir
)
return ret
def builder_action_distribute(self, called_as, log):
ret = autotools.make_high(
self.buildingsite,
log=log,
options=[],
arguments=[
'install', 'install-dev', 'install-lib',
'DESTDIR={}'.format(self.dst_dir)
],
environment=self.builder_action_make_define_environment(
called_as, log),
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'default',
'install',
'PWD={}'.format(self.get_src_dir()),
'KERNELRELEASE={}'.format(self.custom_data['kern_rel']),
'DESTDIR={}'.format(self.get_dst_dir()),
] + self.all_automatic_flags_as_list(),
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'install',
# FIXME: fix path join
'MANDIR={}/share/man'.format(self.calculate_install_prefix()),
# 'MANSUFFIX=ssl',
'INSTALL_PREFIX=' + self.get_dst_dir(),
'DESTDIR=' + self.get_dst_dir(),
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute_a(self, called_as, log):
os.makedirs(wayround_i2p.utils.path.join(
self.calculate_dst_install_prefix()),
exist_ok=True)
ret = autotools.make_high(
self.buildingsite_path,
options=[],
arguments=[
'install',
'prefix={}'.format(self.calculate_dst_install_prefix())
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'install',
'DESTDIR={}'.format(self.get_dst_dir()),
# NOTE: it's not an error INSTALL_OWNER must be empty
'INSTALL_OWNER='
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir
)
return ret
def main(buildingsite, action=None):
ret = 0
r = wayround_i2p.aipsetup.build.build_script_wrap(
buildingsite, ['extract', 'distribute'], action, "help")
if not isinstance(r, tuple):
logging.error("Error")
ret = r
else:
pkg_info, actions = r
src_dir = wayround_i2p.aipsetup.build.getDIR_SOURCE(buildingsite)
dst_dir = wayround_i2p.aipsetup.build.getDIR_DESTDIR(buildingsite)
separate_build_dir = False
source_configure_reldir = '.'
if 'extract' in actions:
if os.path.isdir(src_dir):
logging.info("cleaningup source dir")
wayround_i2p.utils.file.cleanup_dir(src_dir)
ret = autotools.extract_high(buildingsite,
pkg_info['pkg_info']['basename'],
unwrap_dir=True,
rename_dir=False)
if 'distribute' in actions and ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=['install', 'DESTDIR=' + dst_dir, 'PREFIX=/usr'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
return ret
def builder_action_so(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'CFLAGS= -fpic -fPIC -Wall -Winline -O2 -g '
'-D_FILE_OFFSET_BITS=64', 'PREFIX={}'.format(
self.calculate_dst_install_prefix())
] + [self.custom_data['thr']['CC']] +
[self.custom_data['thr']['AR']] +
[self.custom_data['thr']['RANLIB']],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir,
make_filename='Makefile-libbz2_so')
return ret
def builder_action_distr_modules(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'modules_install', 'INSTALL_MOD_PATH=' + self.get_dst_dir()
] + self.custom_data['crossbuild_arch_params'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
if ret == 0:
modules_dir = wayround_i2p.utils.path.join(self.get_dst_dir(),
'lib', 'modules')
files = os.listdir(modules_dir)
if len(files) != 1:
log.error("Can't find directory in {}".format(modules_dir))
ret = 1
else:
modules_dir = \
wayround_i2p.utils.path.join(modules_dir, files[0])
for i in ['build', 'source']:
new_link = wayround_i2p.utils.path.join(modules_dir, i)
wayround_i2p.utils.file.remove_if_exists(new_link)
os.symlink(
wayround_i2p.utils.path.join(
os.path.sep + self.usr_list_item[0], 'src',
'linux-{}'.format(
self.get_package_info()['pkg_nameinfo']
['groups']['version'])), new_link)
return ret
def builder_action_build(self, called_as, log):
if self.get_host_from_pkgi() != 'x86_64-pc-linux-gnu':
raise Exception("fix for others is required")
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'PREFIX={}'.format(self.calculate_install_prefix()),
'CFLAGS= -fpic -fPIC -Wall -Winline -O2 -g '
'-D_FILE_OFFSET_BITS=64', 'libbz2.a', 'bzip2', 'bzip2recover'
] + [self.custom_data['thr']['CC']] +
[self.custom_data['thr']['AR']] +
[self.custom_data['thr']['RANLIB']],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute(self, called_as, log):
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'all', 'install', 'LIBDIR={}'.format(
wayround_i2p.utils.path.join(
self.calculate_install_prefix(),
'lib')), 'BINDIR={}'.format(
wayround_i2p.utils.path.join(
self.calculate_install_prefix(), 'bin')),
'PN531_PATH={}'.format(
wayround_i2p.utils.path.join(
self.calculate_install_prefix(), 'src',
'nfc')), 'DESTDIR={}'.format(self.get_dst_dir())
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def builder_action_distribute(self, called_as, log):
arch_dir = self.get_dst_host_dir()
for i in [
self.calculate_dst_install_libdir(),
wayround_i2p.utils.path.join(
self.calculate_dst_install_prefix(), 'include')
]:
os.makedirs(i, exist_ok=True)
ret = autotools.make_high(
self.buildingsite_path,
log=log,
options=[],
arguments=[
'install',
'PREFIX={}'.format(self.calculate_dst_install_prefix())
],
environment={},
environment_mode='copy',
use_separate_buildding_dir=self.separate_build_dir,
source_configure_reldir=self.source_configure_reldir)
return ret
def main(buildingsite, action=None):
ret = 0
r = wayround_i2p.aipsetup.build.build_script_wrap(
buildingsite, ['extract', 'configure', 'build', 'distribute'], action,
"help")
if not isinstance(r, tuple):
logging.error("Error")
ret = r
else:
pkg_info, actions = r
src_dir = wayround_i2p.aipsetup.build.getDIR_SOURCE(buildingsite)
dst_dir = wayround_i2p.aipsetup.build.getDIR_DESTDIR(buildingsite)
separate_build_dir = False
source_configure_reldir = '.'
if 'extract' in actions:
if os.path.isdir(src_dir):
logging.info("cleaningup source dir")
wayround_i2p.utils.file.cleanup_dir(src_dir)
ret = autotools.extract_high(buildingsite,
pkg_info['pkg_info']['basename'],
unwrap_dir=True,
rename_dir=False)
if 'configure' in actions and ret == 0:
ret = autotools.configure_high(
buildingsite,
options=[],
arguments=[],
environment={},
environment_mode='copy',
source_configure_reldir=source_configure_reldir,
use_separate_buildding_dir=separate_build_dir,
script_name='configure',
run_script_not_bash=False,
relative_call=False)
if 'build' in actions and ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=[],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
if ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=['shared'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
if ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=['static'],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
if 'distribute' in actions and ret == 0:
dst_bin = wayround_i2p.utils.path.join(dst_dir, 'usr', 'bin')
dst_lib = wayround_i2p.utils.path.join(dst_dir, 'usr', 'lib')
dst_inc = wayround_i2p.utils.path.join(dst_dir, 'usr', 'include')
dst_man1 = wayround_i2p.utils.path.join(dst_dir, 'usr', 'share',
'man', 'man1')
dst_man3 = wayround_i2p.utils.path.join(dst_dir, 'usr', 'share',
'man', 'man3')
for i in [dst_bin, dst_lib, dst_inc, dst_man1, dst_man3]:
if not os.path.isdir(i):
os.makedirs(i)
for i in ['dnsget', 'ex-rdns', 'rblcheck']:
for j in ['', '_s']:
shutil.copy(
wayround_i2p.utils.path.join(src_dir,
'{}{}'.format(i, j)),
dst_bin,
)
for i in (
glob.glob(wayround_i2p.utils.path.join(src_dir, '*.so*')) +
glob.glob(wayround_i2p.utils.path.join(src_dir, '*.a'))):
b = os.path.basename(i)
shutil.copy(wayround_i2p.utils.path.join(src_dir, b), dst_lib)
shutil.copy(wayround_i2p.utils.path.join(src_dir, 'udns.h'),
dst_inc)
for i in ['dnsget.1', 'rblcheck.1']:
shutil.copy(
wayround_i2p.utils.path.join(src_dir, i),
dst_man1,
)
for i in ['udns.3']:
shutil.copy(
wayround_i2p.utils.path.join(src_dir, i),
dst_man3,
)
return ret
def main(buildingsite, action=None):
ret = 0
r = wayround_i2p.aipsetup.build.build_script_wrap(
buildingsite, ['extract', 'configure', 'build', 'distribute'], action,
"help")
if not isinstance(r, tuple):
logging.error("Error")
ret = r
else:
pkg_info, actions = r
tar_dir = wayround_i2p.aipsetup.build.getDIR_TARBALL(buildingsite)
src_dir = wayround_i2p.aipsetup.build.getDIR_SOURCE(buildingsite)
dst_dir = wayround_i2p.aipsetup.build.getDIR_DESTDIR(buildingsite)
src_jdk_dir = wayround_i2p.utils.path.join(src_dir, 'openjdk.build',
'j2sdk-image')
java_exec = wayround_i2p.utils.path.join(src_jdk_dir, 'bin', 'java')
java_dir = wayround_i2p.utils.path.join(dst_dir, 'usr', 'lib', 'java')
etc_dir = wayround_i2p.utils.path.join(dst_dir, 'etc', 'profile.d',
'SET')
java009 = wayround_i2p.utils.path.join(etc_dir, '009.java')
classpath000 = wayround_i2p.utils.path.join(etc_dir, '000.classpath')
separate_build_dir = False
source_configure_reldir = '.'
envi = copy.deepcopy(os.environ)
if 'JAVA_HOME' in envi:
del envi['JAVA_HOME']
if 'extract' in actions:
if os.path.isdir(src_dir):
logging.info("cleaningup source dir")
wayround_i2p.utils.file.cleanup_dir(src_dir)
ret = autotools.extract_high(buildingsite,
pkg_info['pkg_info']['basename'],
unwrap_dir=True,
rename_dir=False)
if 'configure' in actions and ret == 0:
ret = autotools.configure_high(
buildingsite,
options=[
# '--disable-tests',
# '--disable-jdk-tests',
# '--disable-langtools-tests',
# '--disable-hotspot-tests',
# '--disable-bootstrap',
# '--with-jdk-home=/home/agu/_sda3/_UNICORN/b2/java/jdk1.7.0_55',
'--enable-system-zlib',
'--enable-system-jpeg',
'--enable-system-png',
'--enable-system-gif',
'--enable-system-lcms',
'--enable-system-gtk',
'--enable-system-gio',
'--enable-system-fontconfig',
'--with-jdk-home=/usr/lib/java/jdk',
'--prefix=' + pkg_info['constitution']['paths']['usr'],
'--mandir=' + pkg_info['constitution']['paths']['man'],
'--sysconfdir=' +
pkg_info['constitution']['paths']['config'],
'--localstatedir=' +
pkg_info['constitution']['paths']['var'],
'--enable-shared',
'--host=' + pkg_info['constitution']['host'],
'--build=' + pkg_info['constitution']['build'],
# '--target=' + pkg_info['constitution']['target']
],
arguments=[],
environment=envi,
environment_mode='copy',
source_configure_reldir=source_configure_reldir,
use_separate_buildding_dir=separate_build_dir,
script_name='configure',
run_script_not_bash=False,
relative_call=False)
if 'build' in actions and ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=[],
environment=envi,
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
if 'distribute' in actions and ret == 0:
ver = ''
p = subprocess.Popen([java_exec, '-version'],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
comm = p.communicate()
stdou = comm[0]
ver_str = str(stdou.splitlines()[0], encoding='utf-8')
m = re.match('java version "(.*)"', ver_str)
if not m:
logging.error("Error getting version")
ret = 10
else:
ver = m.group(1)
teaname = 'icedtea-' + ver
print(teaname)
jdk_dir = wayround_i2p.utils.path.join(java_dir, teaname)
os.makedirs(java_dir, exist_ok=True)
wayround_i2p.utils.file.copytree(src_jdk_dir,
jdk_dir,
clear_before_copy=True,
overwrite_files=True,
dst_must_be_empty=False)
for i in [
wayround_i2p.utils.path.join(java_dir, 'jre'),
wayround_i2p.utils.path.join(java_dir, 'jdk'),
wayround_i2p.utils.path.join(java_dir, 'java')
]:
if os.path.islink(i):
os.unlink(i)
os.symlink(teaname, i)
os.makedirs(etc_dir, exist_ok=True)
fi = open(java009, 'w')
fi.write("""\
#!/bin/bash
export JAVA_HOME=/usr/lib/java/jdk
export PATH=$PATH:$JAVA_HOME/bin:$JAVA_HOME/jre/bin
export MANPATH=$MANPATH:$JAVA_HOME/man
if [ "${#LD_LIBRARY_PATH}" -ne "0" ]; then
LD_LIBRARY_PATH+=":"
fi
export LD_LIBRARY_PATH+="$JAVA_HOME/jre/lib/i386:$JAVA_HOME/jre/lib/i386/client"
""")
fi.close()
fi = open(classpath000, 'w')
fi.write("""\
#!/bin/bash
export CLASSPATH='/usr/lib/java/classpath/*'
""")
src_downs = glob.glob(src_dir + os.path.sep + '*.tar*')
for i in src_downs:
logging.info("Copying source {}".format(os.path.basename(i)))
shutil.copyfile(i, tar_dir + os.path.sep + os.path.basename(i))
return ret
def main(buildingsite, action=None):
ret = 0
r = wayround_i2p.aipsetup.build.build_script_wrap(
buildingsite,
# ['extract', 'exctract_install-tl', 'configure',
# 'build', 'distribute', 'install-tl'],
['extract', 'configure', 'build', 'distribute'],
action,
"help")
if not isinstance(r, tuple):
logging.error("Error")
ret = r
else:
pkg_info, actions = r
src_dir = wayround_i2p.aipsetup.build.getDIR_SOURCE(buildingsite)
tar_dir = wayround_i2p.aipsetup.build.getDIR_TARBALL(buildingsite)
dst_dir = wayround_i2p.aipsetup.build.getDIR_DESTDIR(buildingsite)
install_tl_dir = wayround_i2p.utils.path.join(buildingsite,
'install-tl')
script = wayround_i2p.utils.path.join(install_tl_dir, 'install-tl')
separate_build_dir = True
source_configure_reldir = '.'
usr = pkg_info['constitution']['paths']['usr']
tex_live_dir = wayround_i2p.utils.path.join(usr, 'lib', 'texlive')
dst_tex_live_dir = wayround_i2p.utils.path.join(
dst_dir, 'usr', 'lib', 'texlive')
dst_tex_live_bin = wayround_i2p.utils.path.join(
dst_tex_live_dir, 'bin')
if 'extract' in actions:
if os.path.isdir(src_dir):
logging.info("cleaningup source dir")
wayround_i2p.utils.file.cleanup_dir(src_dir)
ret = autotools.extract_high(buildingsite,
pkg_info['pkg_info']['basename'],
unwrap_dir=True,
rename_dir=False)
if 'exctract_install-tl' in actions and ret == 0:
tl_install = None
lst = os.listdir(tar_dir)
for i in lst:
if i.startswith('install-tl'):
tl_install = i
if not tl_install:
logging.error("install-tl archive not found")
log = wayround_i2p.utils.log.Log(
wayround_i2p.aipsetup.build.getDIR_BUILD_LOGS(buildingsite),
'extract')
tmpdir = tempfile.mkdtemp(
dir=wayround_i2p.aipsetup.build.getDIR_TEMP(buildingsite))
ret = wayround_i2p.utils.archive.extract_low(
log,
tmpdir,
wayround_i2p.utils.path.join(tar_dir, tl_install),
outdir=install_tl_dir,
unwrap_dir=True,
rename_dir=False)
# log.close()
if 'configure' in actions and ret == 0:
ret = autotools.configure_high(
buildingsite,
options=[
'--prefix=' + tex_live_dir,
'--sysconfdir=' +
pkg_info['constitution']['paths']['config'],
'--localstatedir=' +
pkg_info['constitution']['paths']['var'],
'--enable-shared',
'--disable-native-texlive-build',
'--host=' + pkg_info['constitution']['host'],
'--build=' + pkg_info['constitution']['build'],
# '--target=' + pkg_info['constitution']['target']
],
arguments=[],
environment={},
environment_mode='copy',
source_configure_reldir=source_configure_reldir,
use_separate_buildding_dir=separate_build_dir,
script_name='configure',
run_script_not_bash=False,
relative_call=False)
if 'build' in actions and ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=[],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
if 'distribute' in actions and ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=['install', 'DESTDIR=' + dst_dir],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
p_dir = wayround_i2p.utils.path.join(dst_dir, 'etc', 'profile.d',
'SET')
if not os.path.exists(p_dir):
os.makedirs(p_dir)
p_file = wayround_i2p.utils.path.join(p_dir, '009.texlive')
f = open(p_file, 'w')
f.write("""\
#!/bin/bash
TEXPATH={prefix}
export PATH="$PATH:$TEXPATH/bin"
if [ -n "$LD_LIBRARY_PATH" ]
then
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TEXPATH/lib"
else
export LD_LIBRARY_PATH="$TEXPATH/lib"
fi
""".format(host=pkg_info['constitution']['host'], prefix=tex_live_dir))
f.close()
if 'install-tl' in actions and ret == 0:
logging.info(
"Starting start-tl script in dir `{}'".format(install_tl_dir))
p = subprocess.Popen(
[
script, '-repository='
'http://mirrors.wayround.org/www.ctan.org'
'/tex/systems/texlive/tlnet/tlpkg',
'-custom-bin={dst_tex_live_bin}'.format(
host=pkg_info['constitution']['paths']['usr'],
dst_tex_live_bin=dst_tex_live_bin)
],
env={
'TEXLIVE_INSTALL_PREFIX': dst_tex_live_dir,
'TEXLIVE_INSTALL_TEXDIR': dst_tex_live_dir
},
cwd=install_tl_dir)
ret = p.wait()
return ret
def main(buildingsite, action=None):
ret = 0
r = wayround_i2p.aipsetup.build.build_script_wrap(
buildingsite, ['extract', 'configure', 'build', 'distribute'], action,
"help")
if not isinstance(r, tuple):
logging.error("Error")
ret = r
else:
pkg_info, actions = r
src_dir = wayround_i2p.aipsetup.build.getDIR_SOURCE(buildingsite)
dst_dir = wayround_i2p.aipsetup.build.getDIR_DESTDIR(buildingsite)
separate_build_dir = False
source_configure_reldir = '.'
if 'extract' in actions:
if os.path.isdir(src_dir):
logging.info("cleaningup source dir")
wayround_i2p.utils.file.cleanup_dir(src_dir)
ret = autotools.extract_high(buildingsite,
pkg_info['pkg_info']['basename'],
unwrap_dir=True,
rename_dir=False)
if 'configure' in actions and ret == 0:
ret = autotools.configure_high(
buildingsite,
options=[
'--with-botan-config=/usr/bin/botan-config-1.10',
'--prefix=' + pkg_info['constitution']['paths']['usr'],
'--mandir=' + pkg_info['constitution']['paths']['man'],
'--sysconfdir=' +
pkg_info['constitution']['paths']['config'],
'--localstatedir=' +
pkg_info['constitution']['paths']['var'],
'--enable-shared',
'--host=' + pkg_info['constitution']['host'],
'--build=' + pkg_info['constitution']['build'],
# '--target=' + pkg_info['constitution']['target']
],
arguments=[],
environment={},
environment_mode='copy',
source_configure_reldir=source_configure_reldir,
use_separate_buildding_dir=separate_build_dir,
script_name='configure',
run_script_not_bash=False,
relative_call=False)
if 'build' in actions and ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=[],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
if 'distribute' in actions and ret == 0:
ret = autotools.make_high(
buildingsite,
options=[],
arguments=['install', 'DESTDIR=' + dst_dir],
environment={},
environment_mode='copy',
use_separate_buildding_dir=separate_build_dir,
source_configure_reldir=source_configure_reldir)
return ret
