def _send_mgmtworker_task(message, routing_key='workflow'):
"""Send a message to the mgmtworker exchange"""
client = _get_amqp_client()
send_handler = SendHandler(MGMTWORKER_QUEUE, routing_key=routing_key)
client.add_handler(send_handler)
with client:
send_handler.publish(message)
def _send_mgmtworker_task(message, exchange=MGMTWORKER_QUEUE,
exchange_type='direct', routing_key='workflow'):
"""Send a message to the mgmtworker exchange"""
client = _get_amqp_client()
send_handler = SendHandler(exchange, exchange_type,
routing_key=routing_key)
client.add_handler(send_handler)
with client:
send_handler.publish(message)
def _broadcast_mgmtworker_task(message,
exchange='cloudify-mgmtworker-service',
exchange_type='fanout',
routing_key='service'):
"""Broadcast a message to all mgmtworkers in a cluster."""
client = get_amqp_client()
send_handler = SendHandler(exchange,
exchange_type,
routing_key=routing_key)
client.add_handler(send_handler)
with client:
send_handler.publish(message)
def _send_mgmtworker_task(message, routing_key='workflow'):
"""Send a message to the mgmtworker exchange"""
client = get_client(amqp_host=config.instance.amqp_host,
amqp_user=config.instance.amqp_username,
amqp_pass=config.instance.amqp_password,
amqp_port=BROKER_SSL_PORT,
amqp_vhost='/',
ssl_enabled=True,
ssl_cert_path=config.instance.amqp_ca_path)
send_handler = SendHandler(MGMTWORKER_QUEUE, routing_key=routing_key)
client.add_handler(send_handler)
with client:
send_handler.publish(message)
def execute_workflow(
execution,
bypass_maintenance=None,
wait_after_fail=600,
handler: SendHandler = None,
):
sm = get_storage_manager()
token = generate_execution_token(execution)
context = execution.render_context()
context.update({
'wait_after_fail':
wait_after_fail,
'bypass_maintenance':
bypass_maintenance,
'execution_token':
token,
'rest_host':
[manager.private_ip for manager in sm.list(models.Manager)],
'rest_token':
execution.creator.get_auth_token(),
})
if context.get('plugin'):
managed_plugins = sm.list(models.Plugin,
filters={
'package_name':
context['plugin'].get('package_name'),
'package_version':
context['plugin'].get('package_version'),
}).items
if managed_plugins:
context['plugin']['visibility'] = managed_plugins[0].visibility
context['plugin']['tenant_name'] = managed_plugins[0].tenant_name
execution_parameters = execution.parameters.copy()
execution_parameters['__cloudify_context'] = context
message = {
'cloudify_task': {
'kwargs': execution_parameters
},
'id': execution.id,
'execution_creator': execution.creator.id
}
if handler is not None:
handler.publish(message)
else:
_send_mgmtworker_task(message)
def patch(self):
"""Replace CA certificates on running agents."""
request_dict = get_json_and_verify_params({'bundle': {'type': bool}})
# broker_ca_cert or manager_ca_cert can be None so no need to
# specify their type
broker_ca_cert = request_dict.get('broker_ca_cert')
manager_ca_cert = request_dict.get('manager_ca_cert')
bundle = request_dict.get('bundle')
sm = get_storage_manager()
num_of_updated_agents = 0
new_broker_ca, new_manager_ca = self._get_new_ca_certs(
sm, bundle, broker_ca_cert, manager_ca_cert)
all_tenants = sm.list(models.Tenant, get_all_results=True)
for tenant in all_tenants:
tenant_agents = sm.list(models.Agent,
get_all_results=True,
all_tenants=True,
filters={'tenant': tenant})
amqp_client = get_amqp_client(tenant=tenant)
to_send = []
for agent in tenant_agents:
message = {
'service_task': {
'task_name': 'replace-ca-certs',
'kwargs': {
'new_broker_ca': new_broker_ca,
'new_manager_ca': new_manager_ca
}
}
}
handler = SendHandler(agent.rabbitmq_exchange,
exchange_type='direct',
routing_key='service')
to_send.append((handler, message))
amqp_client.add_handler(handler)
num_of_updated_agents += 1
with amqp_client:
for handler, message in to_send:
handler.publish(message)
return {'number_of_updated_agents': num_of_updated_agents}
def _send_cancel_task(self, target, execution_id):
"""Send a cancel-operation task to the agent given by `target`"""
message = {
'service_task': {
'task_name': 'cancel-operation',
'kwargs': {
'execution_id': execution_id
}
}
}
if target == MGMTWORKER_QUEUE:
client = get_client()
else:
tenant = workflow_ctx.tenant
client = get_client(amqp_user=tenant['rabbitmq_username'],
amqp_pass=tenant['rabbitmq_password'],
amqp_vhost=tenant['rabbitmq_vhost'])
handler = SendHandler(exchange=target, routing_key='service')
client.add_handler(handler)
with client:
handler.publish(message)
def uninstall_plugin(plugin):
sm = get_storage_manager()
pstates = sm.list(models._PluginState,
filters={
'_plugin_fk':
plugin._storage_id,
'state': [
PluginInstallationState.INSTALLED,
PluginInstallationState.INSTALLING,
PluginInstallationState.ERROR
]
})
agents_per_tenant = {}
managers = []
for pstate in pstates:
if pstate.manager:
managers.append(pstate.manager.hostname)
if pstate.agent:
agents_per_tenant.setdefault(pstate.agent.tenant,
[]).append(pstate.agent)
if managers:
_broadcast_mgmtworker_task(
_get_plugin_message(plugin,
target_names=managers,
task='uninstall-plugin'))
agent_message = _get_plugin_message(plugin, task='uninstall-plugin')
if agents_per_tenant:
for tenant, agents in agents_per_tenant.items():
# amqp client for the given tenant's vhost.
# Still use the manager's creds.
tenant_client = get_amqp_client(tenant)
with tenant_client:
for agent in agents:
send_handler = SendHandler(agent.name,
exchange_type='direct',
routing_key='service')
tenant_client.add_handler(send_handler)
send_handler.publish(agent_message)
def _send_cancel_task(self, target, execution_id):
"""Send a cancel-operation task to the agent given by `target`"""
message = {
'service_task': {
'task_name': 'cancel-operation',
'kwargs': {'execution_id': execution_id}
}
}
if target == MGMTWORKER_QUEUE:
client = get_client()
else:
tenant = workflow_ctx.tenant
client = get_client(
amqp_user=tenant['rabbitmq_username'],
amqp_pass=tenant['rabbitmq_password'],
amqp_vhost=tenant['rabbitmq_vhost']
)
handler = SendHandler(exchange=target, routing_key='service')
client.add_handler(handler)
with client:
handler.publish(message)
def workflow_sendhandler() -> SendHandler:
return SendHandler(MGMTWORKER_QUEUE, 'direct', routing_key='workflow')