def builder_action_patch(self, called_as, log):
series_file_path = wayround_i2p.utils.path.join(
self.get_patches_dir(), 'series')
series = []
if os.path.isfile(series_file_path):
with open(series_file_path) as f:
series = f.read().split('\n')
for i in series:
p_file = wayround_i2p.utils.path.join(self.get_patches_dir(), i)
if os.path.isfile(p_file):
log.info("applying patch {}".format(i))
with open(p_file) as f:
p_text = f.read()
p = subprocess.Popen(['patch', '-p1'],
cwd=self.get_src_dir(),
stdin=subprocess.PIPE,
stdout=log.stdout,
stderr=log.stderr)
p.communicate(bytes(p_text, 'utf-8'))
if p.wait() != 0:
ret = 1
return 0
def cmake_high(
building_site,
options,
arguments,
environment,
environment_mode,
source_subdir,
build_in_separate_dir,
log=None,
):
building_site = wayround_i2p.utils.path.abspath(building_site)
own_log = False
if log is None:
own_log = True
log = wayround_i2p.utils.log.Log(
wayround_i2p.aipsetup.build.getDIR_BUILD_LOGS(building_site),
'cmake'
)
env = wayround_i2p.utils.osutils.env_vars_edit(
environment,
environment_mode
)
if len(environment) > 0:
log.info(
"Environment modifications:\n{}".format(
pprint.pformat(environment)
)
)
script_path = determine_abs_configure_dir(
building_site,
source_subdir
)
working_dir = determine_building_dir(
building_site,
source_subdir,
build_in_separate_dir
)
ret = cmake_low(
log=log,
build_dir=working_dir,
src_dir=script_path,
working_dir=working_dir,
opts=options,
args=arguments,
env=env
)
# if own_log:
# log.close()
return ret
def import_from_spool_element(
self,
spool_element_obj,
log,
stop_event=None
):
if not isinstance(spool_element_obj, SpoolElement):
raise TypeError(
"`spool_element_obj' must be inst of SpoolElement"
)
self.makedirs()
# ------------------------------------------------------------------
log.info("Transferring data")
received = spool_element_obj.get_received()
return_path = spool_element_obj.get_return_path()
speo_file = spool_element_obj.flagged.open_flag('data', 'br')
tmeo_file = self.flagged.open_flag('data', 'bw')
if received is not None:
log.info(" prepending Received field")
tmeo_file.write(b"Received: ")
tmeo_file.write(bytes(received, 'utf-8'))
tmeo_file.write(wayround_i2p.mail.miscs.STANDARD_LINE_TERMINATOR)
if return_path is not None:
log.info(" prepending Return-path field")
tmeo_file.write(b"Return-path: ")
tmeo_file.write(bytes(return_path, 'utf-8'))
tmeo_file.write(wayround_i2p.mail.miscs.STANDARD_LINE_TERMINATOR)
log.info(" transferring rest of the data")
while True:
if stop_event is not None and stop_event.is_set():
break
buf = speo_file.read(2 * 1024**2)
if len(buf) == 0:
break
tmeo_file.write(buf)
speo_file.close()
tmeo_file.close()
del speo_file, tmeo_file, received, return_path
log.info(" DONE: data transfer complete")
self.reindex(stop_event, log)
return
def builder_action_dst_cleanup(self, called_as, log):
"""
Standard destdir cleanup
"""
if os.path.isdir(self.get_dst_dir()):
log.info("cleaningup destination dir")
wayround_i2p.utils.file.cleanup_dir(self.get_dst_dir())
return 0
def builder_action_bld_cleanup(self, called_as, log):
"""
Standard building dir cleanup
"""
if os.path.isdir(self.get_bld_dir()):
log.info("cleaningup building dir")
wayround_i2p.utils.file.cleanup_dir(self.get_bld_dir())
return 0
def builder_action_src_cleanup(self, called_as, log):
"""
Standard sources cleanup
"""
if os.path.isdir(self.get_src_dir()):
log.info("cleaningup source dir")
wayround_i2p.utils.file.cleanup_dir(self.get_src_dir())
return 0
def configure_low(log, script_path, working_dir, opts, args, env,
run_script_not_bash, relative_call, script_name):
ret = 0
if relative_call:
script_path = wayround_i2p.utils.path.relpath(script_path, working_dir)
cmd = []
if not run_script_not_bash:
cmd = (['bash'] + [script_path + os.path.sep + script_name] + opts +
args)
else:
cmd = [script_path + os.path.sep + script_name] + opts + args
log.info("directory: {}".format(working_dir))
log.info("command:")
for i in cmd:
log.info(" {}".format(i))
#log.info("command(joined): {}".format(' '.join(cmd)))
p = None
try:
p = subprocess.Popen(
cmd,
env=env,
stdout=log.stdout,
stderr=log.stderr,
# stdin=subprocess.DEVNULL,
cwd=working_dir)
except:
log.error(
"exception while starting configuration script\n"
" command line was:\n"
" " + repr(cmd) +
wayround_i2p.utils.error.return_exception_info(sys.exc_info()))
ret = 100
else:
try:
p.wait()
except KeyboardInterrupt:
raise
except:
log.error(
"Exception occurred while waiting for configure\n" +
wayround_i2p.utils.error.return_exception_info(sys.exc_info()))
ret = 100
else:
tmp_s = "configure return code was: {}".format(p.returncode)
if p.returncode == 0:
log.info(tmp_s)
else:
log.error(tmp_s)
ret = p.returncode
return ret
def make_high(building_site,
options,
arguments,
environment,
environment_mode,
use_separate_buildding_dir,
source_configure_reldir,
log=None,
make_filename=None):
building_site = wayround_i2p.utils.path.abspath(building_site)
own_log = False
if log is None:
own_log = True
log = wayround_i2p.utils.log.Log(
wayround_i2p.aipsetup.build.getDIR_BUILD_LOGS(building_site),
'make')
env = wayround_i2p.utils.osutils.env_vars_edit(environment,
environment_mode)
if len(environment) > 0:
log.info("Environment modifications:")
for i in sorted(list(environment.keys())):
log.info(" {}: {}".format(i, environment[i]))
working_dir = determine_building_dir(building_site,
source_configure_reldir,
use_separate_buildding_dir)
ret = make_low(log,
options,
arguments,
env,
working_dir,
make_filename=make_filename)
# if own_log:
# log.close()
return ret
def make_low(log, opts, args, env, working_dir, make_filename=None):
ret = 0
mfn = []
if make_filename is not None:
mfn = ['-f', make_filename]
cmd = ['make'] + list(mfn) + list(opts) + list(args)
log.info("directory: {}".format(working_dir))
log.info("command:")
for i in cmd:
log.info(" {}".format(i))
# log.info("debug: mfn: {}, opts: {}, args: {}".format(mfn, opts, args))
p = None
try:
p = subprocess.Popen(cmd,
env=env,
stdout=log.stdout,
stderr=log.stderr,
cwd=working_dir)
except:
log.error(
"exception while starting make script\n" +
" command line was:\n" + " " + repr(cmd) + "\n" +
wayround_i2p.utils.error.return_exception_info(sys.exc_info()))
ret = 100
else:
try:
p.wait()
except KeyboardInterrupt:
raise
except:
log.error(
"exception occurred while waiting for builder\n" +
wayround_i2p.utils.error.return_exception_info(sys.exc_info()))
ret = 100
else:
tmp_s = "make return code was: {}".format(p.returncode)
if p.returncode == 0:
log.info(tmp_s)
else:
log.error(tmp_s)
ret = p.returncode
return ret
def builder_action_configure(self, called_as, log):
log.info("crossbuild?: {}, crossbuilder?: {}".format(
self.get_is_crossbuild(), self.get_is_crossbuilder()))
self.check_deprecated_methods(called_as, log)
envs = {}
if hasattr(self, 'builder_action_configure_define_environment'):
envs = self.builder_action_configure_define_environment(
called_as, log)
opts = []
if hasattr(self, 'builder_action_configure_define_opts'):
opts = self.builder_action_configure_define_opts(called_as, log)
args = []
if hasattr(self, 'builder_action_configure_define_args'):
args = self.builder_action_configure_define_args(called_as, log)
ret = autotools.configure_high(
self.buildingsite_path,
log=log,
options=opts,
arguments=args,
environment=envs,
environment_mode='copy',
source_configure_reldir=self.source_configure_reldir,
use_separate_buildding_dir=self.separate_build_dir,
script_name=self.builder_action_configure_define_script_name(
called_as, log),
run_script_not_bash=(
self.builder_action_configure_define_run_script_not_bash(
called_as, log)),
relative_call=(self.builder_action_configure_define_relative_call(
called_as, log)))
#sleeptime = 5
#log.info("sleep: \033[0;1m{}\033[0m seconds".format(sleeptime))
# time.sleep(sleeptime)
return ret
def cmake_low(
log,
build_dir,
src_dir,
working_dir,
opts,
args,
env
):
ret = 0
cmd = ['cmake'] + opts + ['--build=' + build_dir] + args + [src_dir]
log.info("directory: {}".format(working_dir))
log.info("src: {}".format(src_dir))
log.info("build dir: {}".format(build_dir))
log.info("command:")
for i in cmd:
log.info(" {}".format(i))
#log.info("command(joined): {}".format(' '.join(cmd)))
p = None
try:
p = subprocess.Popen(
cmd,
env=env,
stdout=log.stdout,
stderr=log.stderr,
cwd=working_dir
)
except:
log.error(
"exception while starting cmake\n"
" command line was:\n"
" " + repr(cmd) +
wayround_i2p.utils.error.return_exception_info(
sys.exc_info()
)
)
ret = 100
else:
try:
p.wait()
except KeyboardInterrupt:
raise
except:
log.error(
"Exception occurred while waiting for cmake\n{}".format(
wayround_i2p.utils.error.return_exception_info(
sys.exc_info()
)
)
)
ret = 100
else:
tmp_s = "cmake return code was: {}".format(p.returncode)
if p.returncode == 0:
log.info(tmp_s)
else:
log.error(tmp_s)
ret = p.returncode
return ret
def waf(cwd, options, arguments, environment, environment_mode, log):
ret = 0
cwd = wayround_i2p.utils.path.abspath(cwd)
env = wayround_i2p.utils.osutils.env_vars_edit(environment,
environment_mode)
if len(environment) > 0:
log.info("Environment modifications: {}".format(repr(environment)))
if 'PYTHON' in environment:
python = environment['PYTHON']
else:
if 'PATH' in environment:
PATH = environment['PATH']
else:
PATH = os.environ['PATH']
PATH = PATH.split(':')
python = wayround_i2p.utils.file.which('python2', PATH)
del PATH
cmd = [python, wayround_i2p.utils.path.join(cwd, 'waf')
] + options + arguments
log.info("directory: {}".format(cwd))
log.info("command: {}".format(cmd))
log.info("command(joined): {}".format(' '.join(cmd)))
p = None
try:
p = subprocess.Popen(args=cmd,
cwd=cwd,
stdout=log.stdout,
stderr=log.stderr,
env=env)
except:
log.error(
"exception while starting waf script\n"
" command line was:\n"
" " + repr(cmd) +
wayround_i2p.utils.error.return_exception_info(sys.exc_info()))
ret = 100
else:
try:
p.wait()
except:
log.error(
"Exception occurred while waiting for configure\n" +
wayround_i2p.utils.error.return_exception_info(sys.exc_info()))
ret = 100
else:
tmp_s = "configure return code was: {}".format(p.returncode)
if p.returncode == 0:
log.info(tmp_s)
else:
log.error(tmp_s)
ret = p.returncode
return ret
def configure_high(building_site,
options,
arguments,
environment,
environment_mode,
source_configure_reldir,
use_separate_buildding_dir,
script_name,
run_script_not_bash,
relative_call,
log=None):
"""
Start configuration script
source_configure_reldir - relative path from source dir to configure dir;
script_name - configure script name;
run_script_not_bash - run {full_path}/configure, not
bash {full_path}/configure;
relative_call - make {full_path} bee '.'
"""
ret = 0
building_site = wayround_i2p.utils.path.abspath(building_site)
own_log = False
if log is None:
own_log = True
log = wayround_i2p.utils.log.Log(
wayround_i2p.aipsetup.build.getDIR_BUILD_LOGS(building_site),
'configure')
pkg_info = \
wayround_i2p.aipsetup.build.BuildingSiteCtl(building_site).\
read_package_info()
if not isinstance(pkg_info, dict):
log.error("Can't read package info")
ret = 1
else:
env = wayround_i2p.utils.osutils.env_vars_edit(environment,
environment_mode)
if len(environment) > 0:
log.info("Environment modifications:")
for i in sorted(list(environment.keys())):
log.info(" {}:".format(i))
log.info(" {}".format(environment[i]))
script_path = determine_abs_configure_dir(building_site,
source_configure_reldir)
working_dir = determine_building_dir(building_site,
source_configure_reldir,
use_separate_buildding_dir)
ret = configure_low(log, script_path, working_dir, options, arguments,
env, run_script_not_bash, relative_call,
script_name)
# if own_log:
# log.close()
return ret
def import_from_transition(self, transition_message_obj, log=None):
if not isinstance(transition_message_obj, TransitionMessage):
raise TypeError(
"`transition_message_obj' must be inst of TransitionMessage"
)
self.makedirs()
flags_list = transition_message_obj.flagged.get_flags_list()
for i in flags_list:
src_path = transition_message_obj.flagged.get_flag_path(i)
dst_path = self.flagged.get_flag_path(i)
if log is not None:
log.info("Copying:")
log.info(" '{}'".format(src_path))
log.info(" to")
log.info(" '{}'".format(dst_path))
if not os.path.isfile(src_path):
log.info(" source file does not exists")
else:
size = os.stat(src_path).st_size
mb_size = size / 1024 / 1024
log.info(" size: {} bytes ({} MiB)".format(size, mb_size))
shutil.copy2(src_path, dst_path)
log.info("")
return
def reindex(self, stop_event, log):
# ------------------------------------------------------------------
log.info("Calculating data lines..")
self.calculate_data_lines_indexes(log, stop_event)
log.info(" DONE")
# print("get_data_lines: {}".format(self.get_data_lines()))
# ------------------------------------------------------------------
log.info("Determining sections..")
self.calculate_section_lines(log, stop_event)
log.info(" DONE")
# ------------------------------------------------------------------
log.info("Determining title..")
self.calculate_subject(log, stop_event)
log.info(" DONE")
# ------------------------------------------------------------------
log.info("Setting up initial message flags..")
self.setup_initial_flags(log, stop_event)
log.info(" DONE")
# ------------------------------------------------------------------
return
def builder_action_autogen(self, called_as, log):
cfg_script_name = self.builder_action_configure_define_script_name(
called_as, log)
ret = 0
do_work = False
if os.path.isfile(
wayround_i2p.utils.path.join(self.get_src_dir(),
self.source_configure_reldir,
cfg_script_name)):
log.info("configurer found. no generator use presumed")
else:
log.info("configurer not found. generator use presumed")
do_work = True
if self.forced_autogen:
log.info("generator use is forced".format(cfg_script_name))
do_work = True
if do_work:
log.info("trying to find and use generator mesures")
for i in [
('makeconf.sh', ['./makeconf.sh']),
('autogen.sh', ['./autogen.sh']),
('bootstrap.sh', ['./bootstrap.sh']),
('bootstrap', ['./bootstrap']),
('genconfig.sh', ['./genconfig.sh']),
('configure.ac', ['autoreconf', '-i']),
('configure.in', ['autoreconf', '-i']),
]:
if os.path.isfile(
wayround_i2p.utils.path.join(
self.get_src_dir(), self.source_configure_reldir,
i[0])):
log.info("found `{}'. trying to execute: {}".format(
i[0], ' '.join(i[1])))
wd = wayround_i2p.utils.path.join(
self.get_src_dir(), self.source_configure_reldir)
if '/' in i[1][0]:
tgt_file = wayround_i2p.utils.path.join(wd, i[1][0])
log.info("changing mode (+x) for: {}".format(tgt_file))
chmod_p = subprocess.Popen(['chmod', '+x', tgt_file],
cwd=wd)
chmod_p.wait()
if i[1][0].endswith('.sh'):
i[1].insert(0, 'bash')
p = subprocess.Popen(i[1],
cwd=wd,
stdout=log.stdout,
stderr=log.stderr)
ret = p.wait()
break
else:
log.error("./{} not found and no generators found".format(
cfg_script_name))
ret = 2
return ret
