def install_dependencies(dn, dependencies=None):
'''Install recursed dependencies of dn into dn's sandbox.'''
if dependencies is None:
dependencies = dn.get('build-depends', [])
log(dn, 'Installing dependencies\n', dependencies, verbose=True)
shuffle(dependencies)
for it in dependencies:
dependency = app.defs.get(it)
if os.path.exists(
os.path.join(dn['sandbox'], 'baserock',
dependency['name'] + '.meta')):
# dependency has already been installed
log(dn, 'Already did', dependency['name'], verbose=True)
continue
install_dependencies(dn, dependency.get('build-depends', []))
if (it in dn['build-depends']) or \
(dependency.get('build-mode', 'staging') ==
dn.get('build-mode', 'staging')):
compose(dependency)
if dependency.get('contents'):
install_dependencies(dn, dependency['contents'])
sandbox.install(dn, dependency)
if config.get('log-verbose'):
sandbox.list_files(dn)
def install_contents(dn, contents=None):
''' Install contents (recursively) into dn['sandbox'] '''
if contents is None:
contents = dn.get('contents', [])
log(dn, 'Installing contents\n', contents, verbose=True)
shuffle(contents)
for it in contents:
item = app.defs.get(it)
if os.path.exists(
os.path.join(dn['sandbox'], 'baserock',
item['name'] + '.meta')):
# content has already been installed
log(dn, 'Already installed', item['name'], verbose=True)
continue
for i in item.get('contents', []):
install_contents(dn, [i])
if item.get('build-mode', 'staging') != 'bootstrap':
if not get_cache(item):
compose(item)
sandbox.install(dn, item)
if config.get('log-verbose'):
log(dn, 'Added contents\n', contents)
sandbox.list_files(dn)
def assemble(target):
'''Assemble dependencies and contents recursively until target exists.'''
if cache.get_cache(target):
return
defs = Definitions()
this = defs.get(target)
with app.timer(this, 'Starting assembly'):
with sandbox.setup(this):
for it in this.get('build-depends', []):
dependency = defs.get(it)
assemble(dependency)
sandbox.install(this, dependency)
for it in this.get('contents', []):
component = defs.get(it)
if component.get('build-mode') == 'bootstrap':
continue
assemble(component)
sandbox.install(this, component)
if this.get('build-mode') != 'bootstrap':
sandbox.ldconfig(this)
else:
app.log(this, "No ldconfig because bootstrap mode is engaged")
build(this)
if this.get('devices'):
sandbox.create_devices(this)
cache.cache(this)
def install_contents(dn, contents=None):
''' Install contents (recursively) into dn['sandbox'] '''
if contents is None:
contents = dn.get('contents', [])
log(dn, 'Installing contents\n', contents, verbose=True)
shuffle(contents)
for it in contents:
item = app.defs.get(it)
if os.path.exists(os.path.join(dn['sandbox'],
'baserock', item['name'] + '.meta')):
# content has already been installed
log(dn, 'Already installed', item['name'], verbose=True)
continue
for i in item.get('contents', []):
install_contents(dn, [i])
if item.get('build-mode', 'staging') != 'bootstrap':
if not get_cache(item):
compose(item)
sandbox.install(dn, item)
if config.get('log-verbose'):
log(dn, 'Added contents\n', contents)
sandbox.list_files(dn)
def install_dependencies(dn, dependencies=None):
'''Install recursed dependencies of dn into dn's sandbox.'''
if dependencies is None:
dependencies = dn.get('build-depends', [])
log(dn, 'Installing dependencies\n', dependencies, verbose=True)
shuffle(dependencies)
for it in dependencies:
dependency = app.defs.get(it)
if os.path.exists(os.path.join(dn['sandbox'], 'baserock',
dependency['name'] + '.meta')):
# dependency has already been installed
log(dn, 'Already did', dependency['name'], verbose=True)
continue
install_dependencies(dn, dependency.get('build-depends', []))
if (it in dn['build-depends']) or \
(dependency.get('build-mode', 'staging') ==
dn.get('build-mode', 'staging')):
compose(dependency)
if dependency.get('contents'):
install_dependencies(dn, dependency['contents'])
sandbox.install(dn, dependency)
if config.get('log-verbose'):
sandbox.list_files(dn)
def assemble(defs, target):
'''Assemble dependencies and contents recursively until target exists.'''
if cache.get_cache(defs, target):
# needed for artifact splitting
load_manifest(defs, target)
return cache.cache_key(defs, target)
random.seed(datetime.datetime.now())
component = defs.get(target)
if component.get('arch') and component['arch'] != app.config['arch']:
app.log(target, 'Skipping assembly for', component.get('arch'))
return None
def assemble_system_recursively(system):
assemble(defs, system['path'])
for subsystem in system.get('subsystems', []):
assemble_system_recursively(subsystem)
with app.timer(component, 'assembly'):
sandbox.setup(component)
systems = component.get('systems', [])
random.shuffle(systems)
for system in systems:
assemble_system_recursively(system)
dependencies = component.get('build-depends', [])
random.shuffle(dependencies)
for it in dependencies:
dependency = defs.get(it)
assemble(defs, dependency)
sandbox.install(defs, component, dependency)
contents = component.get('contents', [])
random.shuffle(contents)
for it in contents:
subcomponent = defs.get(it)
if subcomponent.get('build-mode') != 'bootstrap':
assemble(defs, subcomponent)
splits = None
if component.get('kind') == 'system':
splits = subcomponent.get('artifacts')
sandbox.install(defs, component, subcomponent, splits)
app.config['counter'] += 1
if 'systems' not in component:
with app.timer(component, 'build'):
build(defs, component)
with app.timer(component, 'artifact creation'):
do_manifest(defs, component)
cache.cache(defs, component,
full_root=component.get('kind') == "system")
sandbox.remove(component)
return cache.cache_key(defs, component)
def install(defs, component, contents):
shuffle(contents)
for it in contents:
content = defs.get(it)
if os.path.exists(os.path.join(component['sandbox'], 'baserock',
content['name'] + '.meta')):
# content has already been installed
if app.config.get('log-verbose'):
app.log(component, 'Already installed', content['name'])
continue
install(defs, component, content.get('contents', []))
compose(defs, content)
if content.get('build-mode', 'staging') != 'bootstrap':
sandbox.install(defs, component, content)
def assemble(defs, target):
'''Assemble dependencies and contents recursively until target exists.'''
if cache.get_cache(defs, target):
return cache.cache_key(defs, target)
component = defs.get(target)
if component.get('arch') and component['arch'] != app.settings['arch']:
app.log(target, 'Skipping assembly for', component.get('arch'))
return None
def assemble_system_recursively(system):
assemble(defs, system['path'])
for subsystem in system.get('subsystems', []):
assemble_system_recursively(subsystem)
with app.timer(component, 'Starting assembly'):
sandbox.setup(component)
for system_spec in component.get('systems', []):
assemble_system_recursively(system_spec)
dependencies = component.get('build-depends', [])
random.shuffle(dependencies)
for it in dependencies:
dependency = defs.get(it)
assemble(defs, dependency)
sandbox.install(defs, component, dependency)
contents = component.get('contents', [])
random.shuffle(contents)
for it in contents:
subcomponent = defs.get(it)
if subcomponent.get('build-mode') != 'bootstrap':
assemble(defs, subcomponent)
sandbox.install(defs, component, subcomponent)
app.settings['counter'] += 1
if 'systems' not in component:
build(defs, component)
do_manifest(component)
cache.cache(defs, component,
full_root=component.get('kind') == "system")
sandbox.remove(component)
return cache.cache_key(defs, component)
def install(defs, component, dependencies):
shuffle(dependencies)
for it in dependencies:
dependency = defs.get(it)
if os.path.exists(os.path.join(component['sandbox'], 'baserock',
dependency['name'] + '.meta')):
# dependency has already been installed
if app.config.get('log-verbose'):
app.log(component, 'Already installed', dependency['name'])
continue
install(defs, component, dependency.get('build-depends', []))
if (it in component['build-depends']) or \
(dependency.get('build-mode', 'staging') ==
component.get('build-mode', 'staging')):
compose(defs, dependency)
if dependency.get('contents'):
install(defs, component, dependency.get('contents'))
sandbox.install(defs, component, dependency)
def install_contents(defs, component, contents=None):
''' Install contents (recursively) into component['sandbox'] '''
component = defs.get(component)
if contents is None:
contents = component.get('contents', [])
log(component, 'Installing contents\n', contents, verbose=True)
shuffle(contents)
for it in contents:
this = defs.get(it)
if os.path.exists(
os.path.join(component['sandbox'], 'baserock',
this['name'] + '.meta')):
# content has already been installed
log(component, 'Already installed', this['name'], verbose=True)
continue
if component.get('kind', 'chunk') == 'system':
artifacts = []
for content in component['contents']:
if content.keys()[0] == this['path']:
artifacts = content[this['path']]
break
if artifacts != [] or config.get('default-splits', []) != []:
compose(defs, this)
install_split_artifacts(defs, component, this, artifacts)
continue
for i in this.get('contents', []):
install_contents(defs, component, [i])
if this.get('build-mode', 'staging') != 'bootstrap':
if not get_cache(defs, this):
compose(defs, this)
sandbox.install(defs, component, this)
if config.get('log-verbose'):
log(component, 'Added contents\n', contents)
sandbox.list_files(component)
def assemble(target):
'''Assemble dependencies and contents recursively until target exists.'''
if cache.get_cache(target):
return cache.cache_key(target)
defs = Definitions()
this = defs.get(target)
if this.get('arch') and this['arch'] != app.settings['arch']:
app.log(target, 'Skipping assembly for', this['arch'])
return None
with app.timer(this, 'Starting assembly'):
sandbox.setup(this)
for it in this.get('systems', []):
system = defs.get(it)
assemble(system)
for subsystem in this.get('subsystems', []):
assemble(subsystem)
dependencies = this.get('build-depends', [])
random.shuffle(dependencies)
for it in dependencies:
dependency = defs.get(it)
assemble(dependency)
sandbox.install(this, dependency)
contents = this.get('contents', [])
random.shuffle(contents)
for it in contents:
component = defs.get(it)
if component.get('build-mode') != 'bootstrap':
assemble(component)
sandbox.install(this, component)
build(this)
do_manifest(this)
cache.cache(this, full_root=this.get('kind', None) == "system")
sandbox.remove(this)
return cache.cache_key(this)
def install_contents(defs, component, contents=None):
''' Install contents (recursively) into component['sandbox'] '''
component = defs.get(component)
if contents is None:
contents = component.get('contents', [])
log(component, 'Installing contents\n', contents, verbose=True)
shuffle(contents)
for it in contents:
this = defs.get(it)
if os.path.exists(os.path.join(component['sandbox'],
'baserock', this['name'] + '.meta')):
# content has already been installed
log(component, 'Already installed', this['name'], verbose=True)
continue
if component.get('kind', 'chunk') == 'system':
artifacts = []
for content in component['contents']:
if content.keys()[0] == this['path']:
artifacts = content[this['path']]
break
if artifacts != [] or config.get('default-splits', []) != []:
compose(defs, this)
install_split_artifacts(defs, component, this, artifacts)
continue
for i in this.get('contents', []):
install_contents(defs, component, [i])
if this.get('build-mode', 'staging') != 'bootstrap':
if not get_cache(defs, this):
compose(defs, this)
sandbox.install(defs, component, this)
if config.get('log-verbose'):
log(component, 'Added contents\n', contents)
sandbox.list_files(component)
def preinstall(defs, component, it):
'''Install it and all its recursed dependencies into component sandbox.'''
dependency = defs.get(it)
if os.path.exists(os.path.join(component['sandbox'], 'baserock',
dependency['name'] + '.meta')):
return
dependencies = dependency.get('build-depends', [])
for dep in dependencies:
it = defs.get(dep)
if (it.get('build-mode', 'staging') ==
dependency.get('build-mode', 'staging')):
preinstall(defs, component, it)
contents = dependency.get('contents', [])
random.shuffle(contents)
for sub in contents:
it = defs.get(sub)
if it.get('build-mode', 'staging') != 'bootstrap':
preinstall(defs, component, it)
assemble(defs, dependency)
sandbox.install(defs, component, dependency)
def preinstall(defs, component, it):
'''Install it and all its recursed dependencies into component sandbox.'''
dependency = defs.get(it)
if os.path.exists(
os.path.join(component['sandbox'], 'baserock',
dependency['name'] + '.meta')):
return
dependencies = dependency.get('build-depends', [])
for dep in dependencies:
it = defs.get(dep)
if (it.get('build-mode',
'staging') == dependency.get('build-mode', 'staging')):
preinstall(defs, component, it)
contents = dependency.get('contents', [])
random.shuffle(contents)
for sub in contents:
it = defs.get(sub)
if it.get('build-mode', 'staging') != 'bootstrap':
preinstall(defs, component, it)
assemble(defs, dependency)
sandbox.install(defs, component, dependency)