def _create_step(self, node):
"""Creates a Step and Promise with the currently available dependencies of the given Node.
If the dependencies of a Node are not available, returns None.
TODO: Content addressing node and its dependencies should only happen if node is cacheable
or in a multi-process environment.
"""
Node.validate_node(node)
# See whether all of the dependencies for the node are available.
deps = dict()
for dep in self._product_graph.dependencies_of(node):
state = self._product_graph.state(dep)
if state is None:
return None
deps[dep] = state
# Additionally, include Noops for any dependencies that were cyclic.
for dep in self._product_graph.cyclic_dependencies_of(node):
noop_state = Noop('Dep from {} to {} would cause a cycle.'.format(node, dep))
deps[dep] = noop_state
# Ready.
self._step_id += 1
return (StepRequest(self._step_id, node, deps, self._project_tree), Promise())
def _add_dependencies(self, node, dependencies):
"""Adds dependency edges from the given src Node to the given dependency Nodes.
Executes cycle detection: if adding one of the given dependencies would create
a cycle, then the _source_ Node is marked as a Noop with an error indicating the
cycle path, and the dependencies are not introduced.
"""
Node.validate_node(node)
if self.is_complete(node):
raise ValueError('Node {} is already completed, and cannot be updated.'.format(node))
# Add deps. Any deps which would cause a cycle are added to _cyclic_dependencies instead,
# and ignored except for the purposes of Step execution.
node_dependencies = self._dependencies[node]
node_cyclic_dependencies = self._cyclic_dependencies[node]
for dependency in dependencies:
if dependency in node_dependencies:
continue
Node.validate_node(dependency)
if self._detect_cycle(node, dependency):
node_cyclic_dependencies.add(dependency)
else:
node_dependencies.add(dependency)
self._dependents[dependency].add(node)
# 'touch' the dependencies dict for this dependency, to ensure that an entry exists.
self._dependencies[dependency]
def _create_step(self, node):
"""Creates a Step and Promise with the currently available dependencies of the given Node.
If the dependencies of a Node are not available, returns None.
TODO: Content addressing node and its dependencies should only happen if node is cacheable
or in a multi-process environment.
"""
Node.validate_node(node)
# See whether all of the dependencies for the node are available.
deps = dict()
for dep in self._product_graph.dependencies_of(node):
state = self._product_graph.state(dep)
if state is None:
return None
deps[dep] = state
# Additionally, include Noops for any dependencies that were cyclic.
for dep in self._product_graph.cyclic_dependencies_of(node):
noop_state = Noop('Dep from {} to {} would cause a cycle.'.format(
node, dep))
deps[dep] = noop_state
# Ready.
self._step_id += 1
return (StepRequest(self._step_id, node, deps,
self._project_tree), Promise())
def _create_step(self, node):
"""Creates a Step and Promise with the currently available dependencies of the given Node.
If the dependencies of a Node are not available, returns None.
"""
Node.validate_node(node)
# See whether all of the dependencies for the node are available.
deps = dict()
for dep in self._product_graph.dependencies_of(node):
state_key = self._product_graph.state(dep)
if state_key is None:
return None
deps[dep] = state_key
# Additionally, include Noops for any dependencies that were cyclic.
for dep in self._product_graph.cyclic_dependencies_of(node):
deps[dep] = Noop('Dep from {} to {} would cause a cycle.'.format(node, dep))
# Ready.
self._step_id += 1
return (StepRequest(self._step_id, node, deps, self._project_tree), Promise())
def _create_step(self, node):
"""Creates a Step and Promise with the currently available dependencies of the given Node.
If the dependencies of a Node are not available, returns None.
"""
Node.validate_node(node)
# See whether all of the dependencies for the node are available.
deps = dict()
for dep in self._product_graph.dependencies_of(node):
state = self._product_graph.state(dep)
if state is None:
return None
deps[dep] = state
# Additionally, include Noops for any dependencies that were cyclic.
for dep in self._product_graph.cyclic_dependencies_of(node):
deps[dep] = Noop('Dep from {} to {} would cause a cycle.'.format(node, dep))
# Ready.
self._step_id += 1
return (Step(self._step_id, node, deps, self._node_builder), Promise())
def _add_dependencies(self, node, dependencies):
"""Adds dependency edges from the given src Node to the given dependency Nodes.
Executes cycle detection: if adding one of the given dependencies would create
a cycle, then the _source_ Node is marked as a Noop with an error indicating the
cycle path, and the dependencies are not introduced.
"""
Node.validate_node(node)
if self.is_complete(node):
raise ValueError('Node {} is already completed, and cannot be updated.'.format(node))
# Add deps. Any deps which would cause a cycle are added to _cyclic_dependencies instead,
# and ignored except for the purposes of Step execution.
for dependency in dependencies:
if dependency in self._dependencies[node]:
continue
Node.validate_node(dependency)
if self._detect_cycle(node, dependency):
self._cyclic_dependencies[node].add(dependency)
else:
self._dependencies[node].add(dependency)
self._dependents[dependency].add(node)
# 'touch' the dependencies dict for this dependency, to ensure that an entry exists.
self._dependencies[dependency]