def installComponent(args):
path = folders.globalInstallDirectory(
) if args.act_globally else os.getcwd()
logging.debug('install component %s to %s' % (args.component, path))
# !!! FIXME: should support other URL specs, spec matching should be in
# access module
github_ref_match = GitHub_Ref_RE.match(args.component)
try:
if github_ref_match:
component_name = github_ref_match.group(1)
access.satisfyVersion(component_name,
args.component,
available=dict(),
search_paths=[path],
working_directory=path)
else:
component_name = args.component
access.satisfyVersion(component_name,
'*',
available=dict(),
search_paths=[path],
working_directory=path)
except access_common.Unavailable as e:
logging.error('%s', e)
return 1
os.chdir(component_name)
return installDeps(args, component.Component(os.getcwd()))
def installComponent(args):
path = folders.globalInstallDirectory() if args.act_globally else os.getcwd()
logging.debug('install component %s to %s' % (args.component, path))
# !!! FIXME: should support other URL specs, spec matching should be in
# access module
github_ref_match = GitHub_Ref_RE.match(args.component)
try:
if github_ref_match:
component_name = github_ref_match.group(1)
access.satisfyVersion(
component_name,
args.component,
available = dict(),
search_paths = [path],
working_directory = path
)
else:
component_name = args.component
access.satisfyVersion(
component_name,
'*',
available = dict(),
search_paths = [path],
working_directory = path
)
except access_common.Unavailable as e:
logging.error('%s', e)
return 1
os.chdir(component_name)
return installDeps(args, component.Component(os.getcwd()))
def installComponentAsDependency(args, current_component):
logging.debug('install component %s as dependency of %s' % (args.component, current_component))
if not current_component:
logging.debug(str(current_component.getError()))
logging.error('The current directory does not contain a valid module.')
return -1
target, errors = current_component.satisfyTarget(args.target, additional_config=args.config)
if errors:
for error in errors:
logging.error(error)
return 1
modules_dir = current_component.modulesPath()
from yotta.lib import sourceparse
# check if we have both a name and specification
component_name, component_spec = sourceparse.parseModuleNameAndSpec(args.component)
logging.info('%s, %s', component_name, component_spec)
if component_name == current_component.getName():
logging.error('will not install module %s as a dependency of itself', component_name)
return -1
try:
installed = access.satisfyVersion(
component_name,
component_spec,
available = {current_component.getName():current_component},
search_paths = [modules_dir],
working_directory = modules_dir
)
except access_common.AccessException as e:
logging.error(e)
return 1
# We always add the component to the dependencies of the current component
# (if it is not already present), and write that back to disk. Without
# writing to disk the dependency wouldn't be usable.
if installed and not current_component.hasDependency(component_name):
vs = sourceparse.parseSourceURL(component_spec)
if vs.source_type == 'registry':
saved_spec = current_component.saveDependency(installed)
else:
saved_spec = current_component.saveDependency(installed, component_spec)
current_component.writeDescription()
logging.info('dependency %s: %s written to module.json', component_name, saved_spec)
else:
logging.info('dependency %s is already present in module.json', component_name)
# !!! should only install dependencies necessary for the one thing that
# we're installing (but existing components should be made available to
# satisfy dependencies)
components, errors = current_component.satisfyDependenciesRecursive(
target = target,
available_components = [(current_component.getName(), current_component)],
test = {'own':'toplevel', 'all':True, 'none':False}[args.install_test_deps]
)
return checkPrintStatus(errors, components, current_component, target)
def installComponentAsDependency(args, current_component):
logging.debug('install component %s as dependency of %s' % (args.component, current_component))
if not current_component:
logging.debug(str(current_component.getError()))
logging.error('The current directory does not contain a valid module.')
return -1
target, errors = current_component.satisfyTarget(args.target, additional_config=args.config)
if errors:
for error in errors:
logging.error(error)
return 1
modules_dir = current_component.modulesPath()
#!!! FIXME: non-registry component spec support (see also installComponent
# below), for these the original source should be included in the version
# spec, too
github_ref_match = GitHub_Ref_RE.match(args.component)
try:
if github_ref_match:
component_name = github_ref_match.group(1)
component_spec = args.component
else:
component_name = args.component
component_spec = '*'
if component_name == current_component.getName():
logging.error('will not install module %s as a dependency of itself', component_name)
return -1
installed = access.satisfyVersion(
component_name,
component_spec,
available = {current_component.getName():current_component},
search_paths = [modules_dir],
working_directory = modules_dir
)
except access_common.Unavailable as e:
logging.error(e)
return 1
# We always add the component to the dependencies of the current component
# (if it is not already present), and write that back to disk. Without
# writing to disk the dependency wouldn't be usable.
if installed and not current_component.hasDependency(component_name):
saved_spec = current_component.saveDependency(installed)
current_component.writeDescription()
logging.info('dependency %s: %s written to module.json', component_name, saved_spec)
else:
logging.info('dependency %s is already present in module.json', component_name)
# !!! should only install dependencies necessary for the one thing that
# we're installing (but existing components should be made available to
# satisfy dependencies)
components, errors = current_component.satisfyDependenciesRecursive(
target = target,
available_components = [(current_component.getName(), current_component)],
test = {'own':'toplevel', 'all':True, 'none':False}[args.install_test_deps]
)
return checkPrintStatus(errors, components, current_component, target)
def installComponent(args):
path = folders.globalInstallDirectory() if args.act_globally else os.getcwd()
logging.debug('install component %s to %s' % (args.component, path))
from yotta.lib import sourceparse
# check if we have both a name and specification
component_name, component_spec = sourceparse.parseModuleNameAndSpec(args.component)
try:
access.satisfyVersion(
component_name,
component_spec,
available = dict(),
search_paths = [path],
working_directory = path
)
except access_common.AccessException as e:
logging.error('%s', e)
return 1
os.chdir(component_name)
return installDeps(args, component.Component(os.getcwd()))
def installComponent(args):
path = folders.globalInstallDirectory(
) if args.act_globally else os.getcwd()
logging.debug('install component %s to %s' % (args.component, path))
from yotta.lib import sourceparse
# check if we have both a name and specification
component_name, component_spec = sourceparse.parseModuleNameAndSpec(
args.component)
try:
access.satisfyVersion(component_name,
component_spec,
available=dict(),
search_paths=[path],
working_directory=path)
except access_common.AccessException as e:
logging.error('%s', e)
return 1
os.chdir(component_name)
return installDeps(args, component.Component(os.getcwd()))
def getDerivedTarget(
target_name_and_version,
targets_path,
application_dir = None,
install_missing = True,
update_installed = False,
additional_config = None,
shrinkwrap = None
):
# access, , get components, internal
from yotta.lib import access
from yotta.lib import access_common
''' Get the specified target description, optionally ensuring that it (and
all dependencies) are installed in targets_path.
Returns (DerivedTarget, errors), or (None, errors) if the leaf target
could not be found/installed.
'''
logger.debug('satisfy target: %s' % target_name_and_version);
if ',' in target_name_and_version:
name, version_req = target_name_and_version.split(',')
else:
name = target_name_and_version
version_req = '*'
# shrinkwrap is the raw json form, not mapping form here, so rearrange it
# before indexing:
if shrinkwrap is not None:
shrinkwrap_version_req = {
x['name']: x['version'] for x in shrinkwrap.get('targets', [])
}.get(name, None)
else:
shrinkwrap_version_req = None
if shrinkwrap_version_req is not None:
logger.debug(
'respecting shrinkwrap version %s for %s', shrinkwrap_version_req, name
)
dspec = pack.DependencySpec(
name,
version_req,
shrinkwrap_version_req = shrinkwrap_version_req
)
leaf_target = None
previous_name = dspec.name
search_dirs = [targets_path]
target_hierarchy = []
errors = []
while True:
t = None
try:
if install_missing:
t = access.satisfyVersion(
name = dspec.name,
version_required = dspec.versionReq(),
available = target_hierarchy,
search_paths = search_dirs,
working_directory = targets_path,
update_installed = ('Update' if update_installed else None),
type = 'target',
inherit_shrinkwrap = shrinkwrap
)
else:
t = access.satisfyVersionFromSearchPaths(
name = dspec.name,
version_required = dspec.versionReq(),
search_paths = search_dirs,
type = 'target',
inherit_shrinkwrap = shrinkwrap
)
except access_common.AccessException as e:
errors.append(e)
if not t:
if install_missing:
logger.error(
'could not install target %s for %s' %
(dspec, previous_name)
)
break
else:
target_hierarchy.append(t)
previous_name = dspec.name
assert(isinstance(t, Target))
dspec = t.baseTargetSpec() #pylint: disable=no-member
if not leaf_target:
leaf_target = t
if dspec is None:
break
if leaf_target is None:
return (None, errors)
# if we have a valid target, try to load the app-specific config data (if
# any):
app_config = {}
if application_dir is not None:
app_config_fname = os.path.join(application_dir, App_Config_File)
if os.path.exists(app_config_fname):
try:
app_config = ordered_json.load(app_config_fname)
except Exception as e:
errors.append(Exception("Invalid application config.json: %s" % (e)))
return (DerivedTarget(leaf_target, target_hierarchy[1:], app_config, additional_config), errors)
def installComponentAsDependency(args, current_component):
logging.debug('install component %s as dependency of %s' %
(args.component, current_component))
if not current_component:
logging.debug(str(current_component.getError()))
logging.error('The current directory does not contain a valid module.')
return -1
target, errors = current_component.satisfyTarget(
args.target, additional_config=args.config)
if errors:
for error in errors:
logging.error(error)
return 1
modules_dir = current_component.modulesPath()
from yotta.lib import sourceparse
# check if we have both a name and specification
component_name, component_spec = sourceparse.parseModuleNameAndSpec(
args.component)
logging.info('%s, %s', component_name, component_spec)
if component_name == current_component.getName():
logging.error('will not install module %s as a dependency of itself',
component_name)
return -1
try:
installed = access.satisfyVersion(
component_name,
component_spec,
available={current_component.getName(): current_component},
search_paths=[modules_dir],
working_directory=modules_dir)
except access_common.AccessException as e:
logging.error(e)
return 1
# We always add the component to the dependencies of the current component
# (if it is not already present), and write that back to disk. Without
# writing to disk the dependency wouldn't be usable.
if installed and not current_component.hasDependency(component_name):
saved_spec = current_component.saveDependency(installed)
current_component.writeDescription()
logging.info('dependency %s: %s written to module.json',
component_name, saved_spec)
else:
logging.info('dependency %s is already present in module.json',
component_name)
# !!! should only install dependencies necessary for the one thing that
# we're installing (but existing components should be made available to
# satisfy dependencies)
components, errors = current_component.satisfyDependenciesRecursive(
target=target,
available_components=[(current_component.getName(), current_component)
],
test={
'own': 'toplevel',
'all': True,
'none': False
}[args.install_test_deps])
return checkPrintStatus(errors, components, current_component, target)
def getDerivedTarget(target_name_and_version,
targets_path,
application_dir=None,
install_missing=True,
update_installed=False,
additional_config=None):
# access, , get components, internal
from yotta.lib import access
from yotta.lib import access_common
''' Get the specified target description, optionally ensuring that it (and
all dependencies) are installed in targets_path.
Returns (DerivedTarget, errors), or (None, errors) if the leaf target
could not be found/installed.
'''
logger.debug('satisfy target: %s' % target_name_and_version)
if ',' in target_name_and_version:
name, ver = target_name_and_version.split(',')
dspec = pack.DependencySpec(name, ver)
else:
dspec = pack.DependencySpec(target_name_and_version, "*")
leaf_target = None
previous_name = dspec.name
search_dirs = [targets_path]
target_hierarchy = []
errors = []
while True:
t = None
try:
if install_missing:
t = access.satisfyVersion(
name=dspec.name,
version_required=dspec.versionReq(),
available=target_hierarchy,
search_paths=search_dirs,
working_directory=targets_path,
update_installed=('Update' if update_installed else None),
type='target')
else:
t = access.satisfyVersionFromSearchPaths(
name=dspec.name,
version_required=dspec.versionReq(),
search_paths=search_dirs,
type='target')
except access_common.Unavailable as e:
errors.append(e)
if not t:
if install_missing:
logger.error('could not install target %s for %s' %
(dspec, previous_name))
break
else:
target_hierarchy.append(t)
previous_name = dspec.name
assert (isinstance(t, Target))
dspec = t.baseTargetSpec() #pylint: disable=no-member
if not leaf_target:
leaf_target = t
if dspec is None:
break
if leaf_target is None:
return (None, errors)
# if we have a valid target, try to load the app-specific config data (if
# any):
app_config = {}
if application_dir is not None:
app_config_fname = os.path.join(application_dir, App_Config_File)
if os.path.exists(app_config_fname):
try:
app_config = ordered_json.load(app_config_fname)
except Exception as e:
errors.append(
Exception("Invalid application config.json: %s" % (e)))
return (DerivedTarget(leaf_target, target_hierarchy[1:], app_config,
additional_config), errors)
def installComponentAsDependency(args, current_component):
logging.debug('install component %s as dependency of %s' %
(args.component, current_component))
if not current_component:
logging.debug(str(current_component.getError()))
logging.error('The current directory does not contain a valid module.')
return -1
target, errors = current_component.satisfyTarget(
args.target, additional_config=args.config)
if errors:
for error in errors:
logging.error(error)
return 1
modules_dir = current_component.modulesPath()
#!!! FIXME: non-registry component spec support (see also installComponent
# below), for these the original source should be included in the version
# spec, too
github_ref_match = GitHub_Ref_RE.match(args.component)
try:
if github_ref_match:
component_name = github_ref_match.group(1)
component_spec = args.component
else:
component_name = args.component
component_spec = '*'
if component_name == current_component.getName():
logging.error(
'will not install module %s as a dependency of itself',
component_name)
return -1
installed = access.satisfyVersion(
component_name,
component_spec,
available={current_component.getName(): current_component},
search_paths=[modules_dir],
working_directory=modules_dir)
except access_common.Unavailable as e:
logging.error(e)
return 1
# We always add the component to the dependencies of the current component
# (if it is not already present), and write that back to disk. Without
# writing to disk the dependency wouldn't be usable.
if installed and not current_component.hasDependency(component_name):
saved_spec = current_component.saveDependency(installed)
current_component.writeDescription()
logging.info('dependency %s: %s written to module.json',
component_name, saved_spec)
else:
logging.info('dependency %s is already present in module.json',
component_name)
# !!! should only install dependencies necessary for the one thing that
# we're installing (but existing components should be made available to
# satisfy dependencies)
components, errors = current_component.satisfyDependenciesRecursive(
target=target,
available_components=[(current_component.getName(), current_component)
],
test={
'own': 'toplevel',
'all': True,
'none': False
}[args.install_test_deps])
return checkPrintStatus(errors, components, current_component, target)
