-- first, standard build mode and settings for all
for _,resultname in ipairs(ordered_results) do
local res = result.results[resultname]
- res:build_mode(build_mode)
- res:build_settings(e2build.build_settings_class:new())
+ local bp = res:build_process(res:build_process_new())
+ bp:build_mode(build_mode)
+ bp:build_settings(bp:build_settings_new("build"))
end
-- selected results
e2lib.logf(4, "selected_results=%s", table.concat(selected_results, " "))
for _,resultname in ipairs(selected_results) do
local res = result.results[resultname]
- res:build_settings():selected(true)
- res:build_settings():force_rebuild(force_rebuild)
- res:build_settings():keep_chroot(keep_chroot)
- res:build_settings():prep_playground(playground)
+ local bp = res:build_process()
+ bp:build_settings():selected(true)
+ bp:build_settings():force_rebuild(force_rebuild)
+ bp:build_settings():keep_chroot(keep_chroot)
+ bp:build_settings():prep_playground(playground)
end
-- specific build modi
e2lib.logf(4, "tag_mode_results=%s", table.concat(tag_mode_results, " "))
for _,resultname in ipairs(tag_mode_results) do
local res = result.results[resultname]
- res:build_settings():selected(true)
- res:build_settings():force_rebuild(force_rebuild)
- res:build_settings():keep_chroot(keep_chroot)
- res:build_settings():prep_playground(playground)
- res:build_mode(policy.default_build_mode("tag"))
+ local bp = res:build_process()
+ bp:build_settings():selected(true)
+ bp:build_settings():force_rebuild(force_rebuild)
+ bp:build_settings():keep_chroot(keep_chroot)
+ bp:build_settings():prep_playground(playground)
+ bp:build_mode(policy.default_build_mode("tag"))
end
e2lib.logf(4, "branch_mode_results=%s", table.concat(branch_mode_results, " "))
for _,resultname in ipairs(branch_mode_results) do
local res = result.results[resultname]
- res:build_settings():selected(true)
- res:build_settings():force_rebuild(force_rebuild)
- res:build_settings():keep_chroot(keep_chroot)
- res:build_settings():prep_playground(playground)
- res:build_mode(policy.default_build_mode("branch"))
+ local bp = res:build_process()
+ bp:build_settings():selected(true)
+ bp:build_settings():force_rebuild(force_rebuild)
+ bp:build_settings():keep_chroot(keep_chroot)
+ bp:build_settings():prep_playground(playground)
+ bp:build_mode(policy.default_build_mode("branch"))
end
e2lib.logf(4, "wc_mode_results=%s", table.concat(wc_mode_results, " "))
for _,resultname in ipairs(wc_mode_results) do
local res = result.results[resultname]
- res:build_settings():selected(true)
- res:build_settings():force_rebuild(force_rebuild)
- res:build_settings():keep_chroot(keep_chroot)
- res:build_settings():prep_playground(playground)
- res:build_mode(policy.default_build_mode("working-copy"))
+ local bp = res:build_process()
+ bp:build_settings():selected(true)
+ bp:build_settings():force_rebuild(force_rebuild)
+ bp:build_settings():keep_chroot(keep_chroot)
+ bp:build_settings():prep_playground(playground)
+ bp:build_mode(policy.default_build_mode("working-copy"))
end
rc, re = e2tool.print_selection(ordered_results)
error(err.new("unknown result: %s", arguments[1]))
end
- -- apply the standard build mode to all results
- for _,res in pairs(result.results) do
- res:build_mode(build_mode)
+ local ordered_results, re = e2tool.dlist_recursive({arguments[1]})
+ if not ordered_results then
+ error(re)
+ end
+
+ -- set up build process and mode for all involved results
+ for _,resultname in ipairs(ordered_results) do
+ local res2 = result.results[resultname]
+ res2:build_process(res2:build_process_new())
+ res2:build_process():build_mode(build_mode)
end
- local bc
+ -- set up build setting for selected result
+ local bp, bs, bc
+ bp = res:build_process()
+ bs = bp:build_settings(bp:build_settings_new("playground"))
+
bc, re = res:build_config()
if not bc then
error(re)
e2lib.finish(0)
end
- local settings = e2build.playground_settings_class:new()
-
-- interactive mode, use bash profile
local out = {}
table.insert(out, string.format("export TERM='%s'\n",
table.insert(out, string.format("source %s/script/%s\n",
bc.Tc, bc.buildrc_noinit_file))
end
- settings:profile(table.concat(out))
+ bs:profile(table.concat(out))
local command
if opts.command then
- settings:command(
+ bs:command(
string.format("/bin/bash --rcfile '%s' -c '%s'", bc.profile,
opts.command))
else
- settings:command(string.format("/bin/bash --rcfile '%s'", bc.profile))
+ bs:command(string.format("/bin/bash --rcfile '%s'", bc.profile))
end
e2lib.logf(2, "entering playground for %s", res:get_name())
e2lib.log(2, "type `runinit' to run the init files")
end
- res:build_settings(settings)
- rc, re = res:build_process():build(res, "playground")
+ rc, re = bp:build(res, "playground")
if not rc then
error(e:cat(re))
end
table.insert(self._modes[process_mode], pos + 1, { name = name, func = func })
end
+--- Create new build settings instance for the desired process mode.
+-- @param process_mode A process mode like "build" or "playground".
+-- @return Build settings instance
+-- @error Throws assertion/error on invalid process_mode.
+function e2build.build_process_class:build_settings_new(process_mode)
+ assertIsStringN(process_mode)
+
+ if process_mode == "build" then
+ return e2build.build_settings_class:new()
+ elseif process_mode == "playground" then
+ return e2build.playground_settings_class:new()
+ end
+
+ error("build_process_class:build_settings_new(): unknown process_mode")
+end
+
+--- Get/set the build process settings.
+-- @param bs Build settings instance to set (optional).
+-- @return Build settings instance.
+-- @error Throws assertion if unset and on invalid input.
+function e2build.build_process_class:build_settings(bs)
+ if bs then
+ assertIsTable(bs)
+ self._build_settings = bs
+ else
+ assertIsTable(self._build_settings)
+ end
+
+ return self._build_settings
+end
+
+-- Get/set the build mode.
+-- @param bm Build mode table to set (optional)
+-- @return Build mode table.
+-- @error Throws assertion if unset and on invalid input.
+function e2build.build_process_class:build_mode(bm)
+ if bm then
+ assertIsTable(bm)
+ self._build_mode = bm
+ else
+ assertIsTable(self._build_mode)
+ end
+
+ return self._build_mode
+end
+
--- Iterator returns the next step in the chosen build process mode
-- @param process_mode Build process mode
-- @return Iterator function
e = err.new("entering playground")
rc, re = eio.file_write(e2lib.join(bc.c, bc.profile),
- res:build_settings():profile())
+ self:build_settings():profile())
if not rc then
error(e:cat(re))
end
table.insert(cmd, "/bin/sh")
table.insert(cmd, "-c")
- table.insert(cmd, res:build_settings():command())
+ table.insert(cmd, self:build_settings():command())
e2tool.set_umask()
rc, re = e2lib.callcmd(cmd, {})
sbid = string.format("%s...", string.sub(buildid, 1, 8))
- if res:build_settings():prep_playground() then
+ if self:build_settings():prep_playground() then
return_flags.message = e2lib.align(columns,
0, string.format("building %-20s", res:get_name()),
columns, string.format("[%s] [playground]", sbid))
return_flags.stop = false
return true
end
- if res:build_mode().source_set() == "working-copy" or
- res:build_settings():force_rebuild() then
+ if self:build_mode().source_set() == "working-copy" or
+ self:build_settings():force_rebuild() then
return_flags.message = e2lib.align(columns,
0, string.format("building %-20s", res:get_name()),
columns, string.format("[%s]", sbid))
end
local server, location =
- res:build_mode().storage(
+ self:build_mode().storage(
e2project:project_location(), project.release_id())
local result_location = e2lib.join(location, res:get_name(),
buildid, "result.tar")
function e2build.build_process_class:helper_unpack_result(res, dep, destdir)
local rc, re, e
local buildid, server, location, resulttarpath, tmpdir
- local path, resdir, dt, filesdir, e2project
+ local path, resdir, dt, filesdir, e2project, dep_bp
e = err.new("unpacking result failed: %s", dep:get_name())
return false, e:cat(re)
end
+ dep_bp = dep:build_process()
server, location =
- dep:build_mode().storage(e2project:project_location(), project.release_id())
+ dep_bp:build_mode().storage(e2project:project_location(), project.release_id())
e2lib.logf(3, "searching for dependency %s in %s:%s",
dep:get_name(), server, location)
bc = res:build_config()
destdir = e2lib.join(bc.T, "build")
- source_set = res:build_mode().source_set()
+ source_set = self:build_mode().source_set()
for sourcename in res:sources_list():iter() do
e = err.new("installing source failed: %s", sourcename)
---
function e2build.build_process_class:_build_playground(res, return_flags)
- if res:build_settings():prep_playground() then
+ if self:build_settings():prep_playground() then
return_flags.message = string.format("playground done for: %-20s", res:get_name())
return_flags.stop = true
return true
-- -> releases:<project>/<archive>/<release_id>/<result>/files/*
--]]
local e2project = e2tool.e2project()
- if not res:build_mode().deploy then
+ if not self:build_mode().deploy then
e2lib.log(4, "deployment disabled for this build mode")
return true
end
table.insert(files, e2lib.join("files", f))
end
table.insert(files, "checksums")
- local server, location = res:build_mode().deploy_storage(
+ local server, location = self:build_mode().deploy_storage(
e2project:project_location(), project.release_id())
-- do not re-deploy if this release was already done earlier
return false, e:cat(re)
end
- local server, location = res:build_mode().storage(
+ local server, location = self:build_mode().storage(
e2project:project_location(), project.release_id())
local buildid, re = res:buildid()
e = err.new("creating link to last results")
e2project = e2tool.e2project()
-- calculate the path to the result
- server, location = res:build_mode().storage(
+ server, location = self:build_mode().storage(
e2project:project_location(), project.release_id())
-- compute the "last" link/directory
function e2build.build_process_class:_chroot_cleanup(res, return_flags)
local rc, re
-- do not remove chroot if the user requests to keep it
- if not res:build_settings():keep_chroot() then
+ if not self:build_settings():keep_chroot() then
rc, re = self:helper_chroot_remove(res)
if not rc then
return false, re
return false, e:append("no such result: %s", resultname)
end
- local settings = res:build_settings()
+ local bp = res:build_process()
+ local settings = bp:build_settings()
local s = settings:selected() and "[ selected ]" or "[dependency]"
local f = settings:force_rebuild() and "[force rebuild]" or ""
self._type, self._name))
end
---- Get the build process to be used for this class
-function result.basic_result:build_process()
+--- Return new build process for this result
+function result.basic_result:build_process_new()
+ error(err.new("called build_process_new() of result base class, type %s name %s",
+ self._type, self._name))
+end
+
+--- Get/set the build process to be used for this class
+-- @param bp Build process to set (optional).
+function result.basic_result:build_process(bp)
error(err.new("called build_process() of result base class, type %s name %s",
self._type, self._name))
end
self._sources_list = sl.sl:new()
self._chroot_list = sl.sl:new()
self._env = environment.new()
- self._build_mode = false
- self._build_settings = false
+ self._build_process = false
local e = err.new("in result %s:", self._name)
local rc, re
return strict.readonly(bc)
end
----
-function result.result_class:build_mode(bm)
- if bm then
- assertIsTable(bm)
- self._build_mode = bm
- else
- assertIsTable(self._build_mode)
- end
-
- return self._build_mode
-end
-
----
-function result.result_class:build_settings(bs)
- if bs then
- assertIsTable(bs)
- self._build_settings = bs
- else
- assertIsTable(self._build_settings)
- end
-
- return self._build_settings
-end
-
---
function result.result_class:merged_env()
local e = environment.new()
-- @return BuildID or false on error.
-- @return Error object on failure.
function result.result_class:buildid()
- local e, rc, re, hc, id, build_mode
- build_mode = self:build_mode()
+ local e, rc, re, hc, id, bp, build_mode
+ bp = self:build_process()
+ build_mode = bp:build_mode()
if self._buildid then
return build_mode.buildid(self._buildid)
end
---
-function result.result_class:build_process()
- assertIsTable(self._build_mode)
- assertIsTable(self._build_settings)
+function result.result_class:build_process_new()
return e2build.build_process_class:new()
end
+---
+function result.result_class:build_process(bp)
+ if bp ~= nil then
+ self._build_process = bp
+ end
+
+ assertIsTable(self._build_process)
+ return self._build_process
+end
+
---
function result.result_class:attribute_table(flagt)
assert(flagt == nil or type(flagt) == "table")
for sourcename in cp_sources:iter() do
e2lib.logf(3, "source: %s", sourcename)
local destdir = e2lib.join(bc.T, "project", e2tool.sourcedir(sourcename))
- local source_set = res:build_mode().source_set()
+ local bp = res:build_process()
+ local source_set = bp:build_mode().source_set()
local src = source.sources[sourcename]
local source_to_result_fn = _source_to_result_functions[src:get_type()]
return self._stdresult:build_config()
end
-function collect_project_class:build_mode(bm)
- return self._stdresult:build_mode(bm)
-end
-
-function collect_project_class:build_settings(bs)
- return self._stdresult:build_settings(bs)
-end
-
-function collect_project_class:build_process()
- local bp = self._stdresult:build_process()
+function collect_project_class:build_process_new()
+ local bp = self._stdresult:build_process_new()
bp:add_step_before("build", "fix_permissions", "build_collect_project",
_build_collect_project)
return bp
end
+function collect_project_class:build_process(bp)
+ return self._stdresult:build_process(bp)
+end
+
function collect_project_class:chroot_list()
return self._stdresult:chroot_list()
end
projects / e2factory.git / commitdiff