def env(self, parent, default_env):
"""Retrieve env for the dependency.
:param parent: Anod instance in which the dep was declared
:type parent: Anod
:param default_env: default env for the current context
:type default_env: BaseEnv
:return: env object that should be used by the dependency
:rtype: BaseEnv
"""
# Get the current environment associated with the Anod instance
# and adjust it based on dependency parameters
dep_env = BaseEnv(parent.env.build, parent.env.host, parent.env.target)
# For simulation purposes we sometimes load specs as if it was
# loaded on a non local machine thus 'default' does not correspond
# to the default build platform of the local machine.
if self.build == "default":
build = default_env.build.platform
else:
build = self.build
if self.host == "default":
host = default_env.build.platform
else:
host = self.host
if self.target == "default":
target = default_env.build.platform
else:
target = self.target
dep_env.set_env(build, host, target)
return dep_env
def __init__(self,
stack=None,
plan=None,
server=None,
build=None,
host=None,
target=None,
**kwargs):
"""Initialize an execution context or a scope.
:param stack: stack of BaseEnv object that keep track of scopes. Used
only internally
:type stack: list[BaseEnv]
:param server: a BaseEnv object that represent the host default env.
server parameter is taken into account only during creation of
the initial context.
:type server: BaseEnv
:param build: see e3.env.BaseEnv.set_env
:type build: str | None
:param host: see e3.env.BaseEnv.set_env
:type host: str | None
:param target: see e3.env.BaseEnv.set_env
:type target: str | None
:param kwargs: additional data for the current scope/context
:type kwargs: dict
"""
if stack:
# This is a scope creation, so copy current env
self.stack = stack
self.plan = plan
new = self.stack[-1].copy(build=build, host=host, target=target)
else:
self.stack = []
if server is not None:
# This is a new context
new = server.copy(build, host, target)
else:
# This is a new context with no server information. In that
# case retrieve defaults for the local machine.
new = BaseEnv()
new.set_env(build, host, target)
# Store additional data
for k, v in kwargs.iteritems():
setattr(new, k, v)
# And push on the stack
self.stack.append(new)
# Registered functions that correspond to actions. Note that
# there is no need to propagate registered action to children
# scopes. Only initial context use them. The overall scheme
# works also because all scopes refer to the same stack of env
# (because the object is mutable).
self.actions = {}
self.action_list = []
def __init__(self,
stack=None,
plan=None,
server=None,
build=None,
host=None,
target=None,
**kwargs):
"""Initialize an execution context or a scope.
:param stack: stack of BaseEnv object that keep track of scopes. Used
only internally
:type stack: list[BaseEnv]
:param server: a BaseEnv object that represent the host default env.
server parameter is taken into acount only during creation of the
initial context.
:type server: BaseEnv
:param build: see e3.env.BaseEnv.set_env
:type build: str | None
:param host: see e3.env.BaseEnv.set_env
:type host: str | None
:param target: see e3.env.BaseEnv.set_env
:type target: str | None
:param kwargs: additional data for the current scope/context
:type kwargs: dict
"""
if stack:
# This is a scope creation, so copy current env
self.stack = stack
self.plan = plan
new = self.stack[-1].copy(build=build, host=host, target=target)
else:
self.stack = []
if server is not None:
# This is a new context
new = server.copy(build, host, target)
else:
# This is a new context with no server information. In that
# case retrieve defaults for the local machine.
new = BaseEnv()
new.set_env(build, host, target)
# Store additionnal data
for k, v in kwargs.iteritems():
setattr(new, k, v)
# And push on the stack
self.stack.append(new)
# Registered functions that correspond to actions. Note that
# there is no need to propagate registered action to children
# scopes. Only initial context use them. The overall scheme
# works also because all scopes refer to the same stack of env
# (because the object is mutable).
self.actions = {}
def env(self, parent, default_env=None):
"""Retrieve env for the dependency.
:param parent: Anod instance in which the dep was declared
:type parent: Anod
:param default_env: default env for the current context
:type default_env: BaseEnv | None
:return: env object that should be used by the dependency
:rtype: BaseEnv
"""
# Get the current environment associated with the Anod instance
# and adjust it based on dependency parameters
dep_env = BaseEnv(parent.env.build, parent.env.host, parent.env.target)
if self.build == 'default' and default_env is not None:
# For simulation purposes we sometimes load specs as if it was
# load on a non local machine thus 'default' does not correspond
# to the default build platform of the local machine.
build = default_env.build.platform
else:
build = self.build
dep_env.set_env(build, self.host, self.target)
return dep_env
def __init__(
self,
stack: Optional[List[BaseEnv]] = None,
plan: Optional[Plan] = None,
ignore_disabled: bool = True,
server: Optional[BaseEnv] = None,
build: Optional[str] = None,
host: Optional[str] = None,
target: Optional[str] = None,
enabled: bool = True,
**kwargs: Any,
):
"""Initialize an execution context or a scope.
:param stack: stack of BaseEnv object that keep track of scopes. Used
only internally. User instantiation of PlanContext should be done
with stack set to None.
:param plan: the plan to execute
:param ignore_disabled: when true, discard all lines in
blocks "with defaults(enabled=False):"
:param server: a BaseEnv object that represent the host default env.
server parameter is taken into account only during creation of
the initial context.
:param build: see e3.env.BaseEnv.set_env
:param host: see e3.env.BaseEnv.set_env
:param target: see e3.env.BaseEnv.set_env
:param enabled: whether the plan line is enabled or disabled
:param kwargs: additional data for the current scope/context
"""
self.ignore_disabled = ignore_disabled
if stack:
# This is a scope creation, so copy current env
self.stack = stack
self.plan = plan
new = self.stack[-1].copy(build=build, host=host, target=target)
if not enabled:
# we are in a block with enabled=False set, disable all
# lines in that block
new.enabled = enabled
else:
self.stack = []
if server is not None:
# This is a new context
new = server.copy(build, host, target)
else:
# This is a new context with no server information. In that
# case retrieve defaults for the local machine.
new = BaseEnv()
new.set_env(build, host, target)
new.enabled = enabled
# Store additional data
for k, v in kwargs.items():
setattr(new, k, v)
# And push on the stack
self.stack.append(new)
# Registered functions that correspond to actions. Note that
# there is no need to propagate registered action to children
# scopes. Only initial context use them. The overall scheme
# works also because all scopes refer to the same stack of env
# (because the object is mutable).
self.actions: Dict[str, Callable] = {}
self.action_list: List[BaseEnv] = []
