def __init__(self,
cluster,
nodes,
affected_nodes=None,
task_ids=None,
events=None):
"""Initializes.
:param cluster: Cluster instance
:param nodes: the sequence of nodes for deploy
:param affected_nodes: the list of nodes, that affected by deployment
:param task_ids: Only specified tasks will be executed,
If None, all tasks will be executed
:param events: the events (see TaskEvents)
"""
if affected_nodes:
self.affected_node_ids = frozenset(n.uid for n in affected_nodes)
self.deployment_nodes = copy.copy(nodes)
self.deployment_nodes.extend(affected_nodes)
else:
self.deployment_nodes = nodes
self.affected_node_ids = frozenset()
self.cluster = cluster
self.role_resolver = RoleResolver(self.deployment_nodes)
self.task_serializer = DeployTaskSerializer()
self.task_processor = TaskProcessor()
self.tasks_connections = collections.defaultdict(dict)
self.tasks_dictionary = dict()
self.task_filter = self.make_task_filter(task_ids)
self.events = events
def __init__(self, cluster, nodes):
"""Initializes.
:param cluster: Cluster instance
:param nodes: the sequence of nodes for deploy
"""
self.cluster = cluster
self.role_resolver = RoleResolver(nodes)
self.task_serializer = DeployTaskSerializer()
self.task_processor = TaskProcessor()
self.tasks_per_node = collections.defaultdict(dict)
def __init__(self, cluster, nodes, role_resolver=None):
"""Initialises.
:param cluster: the cluster object instance
:param nodes: the list of nodes for deployment
:param role_resolver: the instance of BaseRoleResolver
"""
self.cluster = cluster
self.nodes = nodes
self.role_resolver = role_resolver or RoleResolver(nodes)
def __init__(self, cluster, nodes, task_ids=None):
"""Initializes.
:param cluster: Cluster instance
:param nodes: the sequence of nodes for deploy
:param task_ids: Only specified tasks will be executed,
If None, all tasks will be executed
"""
self.cluster = cluster
self.role_resolver = RoleResolver(nodes)
self.task_serializer = DeployTaskSerializer()
self.task_processor = TaskProcessor()
self.tasks_per_node = collections.defaultdict(dict)
self.task_filter = self.make_task_filter(task_ids)
def stage_tasks_serialize(self, tasks, nodes):
"""Serialize tasks for certain stage
:param stage: oneof consts.STAGES
:param nodes: list of node db objects
"""
serialized = []
role_resolver = RoleResolver(nodes)
for task in tasks:
if self.graph.should_exclude_task(task['id']):
continue
serializer = self.serializers.get_stage_serializer(task)(
task, self.cluster, nodes, role_resolver=role_resolver)
if not serializer.should_execute():
continue
serialized.extend(serializer.serialize())
return serialized
def setUpClass(cls):
cls.tasks = [{
'id': 'task1',
'roles': ['controller'],
'type': 'puppet',
'version': '2.0.0',
'condition': {
'yaql_exp': '$.public_ssl.hostname = localhost'
},
'parameters': {},
'requires': ['task3'],
'required_for': ['task2'],
'cross_depends': [{
'name': 'task2',
'role': 'compute'
}],
'cross_depended_by': [{
'name': 'task3',
'role': 'cinder'
}]
}, {
'id': 'task2',
'roles': ['compute', 'controller'],
'type': 'puppet',
'version': '2.0.0',
'condition': {
'yaql_exp': '$.public_ssl.hostname != localhost'
},
'parameters': {},
'cross_depends': [{
'name': 'task3',
'role': 'cinder'
}]
}, {
'id': 'task3',
'roles': ['cinder', 'controller'],
'type': 'puppet',
'version': '2.0.0',
'condition': 'settings:public_ssl.hostname != "localhost"',
'parameters': {},
'cross_depends': [{
'name': 'task3',
'role': '/.*/'
}],
'cross_depended_by': [{
'name': 'task2',
'role': 'self'
}]
}, {
'id': 'task4',
'roles': ['controller'],
'type': 'puppet',
'version': '2.0.0',
'parameters': {},
'cross_depended_by': [{
'name': 'task3'
}]
}]
cls.nodes = [
mock.MagicMock(uid='1', roles=['controller']),
mock.MagicMock(uid='2', roles=['compute']),
mock.MagicMock(uid='3', roles=['cinder']),
mock.MagicMock(uid='4', roles=['custom']),
]
cls.context = lcm.TransactionContext({
'1': {
'cluster': {
'id': 1
},
'release': {
'version': 'liberty-9.0'
},
'openstack_version': 'liberty-9.0',
'public_ssl': {
'hostname': 'localhost'
},
'attributes': {
'a_str': 'text1',
'a_int': 1
}
},
'2': {
'cluster': {
'id': 1
},
'release': {
'version': 'liberty-9.0'
},
'openstack_version': 'liberty-9.0',
'public_ssl': {
'hostname': 'localhost'
},
'attributes': {
'a_str': 'text2',
'a_int': 2
}
},
'3': {
'cluster': {
'id': 1
},
'release': {
'version': 'liberty-9.0'
},
'openstack_version': 'liberty-9.0',
'public_ssl': {
'hostname': 'localhost'
},
'attributes': {
'a_str': 'text3',
'a_int': 3
}
},
'4': {
'cluster': {
'id': 1
},
'release': {
'version': 'liberty-9.0'
},
'openstack_version': 'liberty-9.0',
'public_ssl': {
'hostname': 'localhost'
},
'attributes': {
'a_str': 'text3',
'a_int': 3
}
}
})
with mock.patch('nailgun.utils.role_resolver.objects') as m_objects:
m_objects.Node.all_roles = lambda x: x.roles
cls.role_resolver = RoleResolver(cls.nodes)
def initialize(self, cluster):
self.all_nodes = objects.Cluster.get_nodes_not_for_deletion(cluster)
self.role_resolver = RoleResolver(self.all_nodes)
self.initialized = cluster.id
def __init__(self, task, cluster, nodes, role_resolver=None):
super(StandardConfigRolesHook, self).__init__(task, cluster)
self.nodes = nodes
self.role_resolver = role_resolver or RoleResolver(nodes)
