def start(cloudify_agent, installer, **_):
if ctx.type == context.NODE_INSTANCE:
if cloudify_agent['remote_execution']:
ctx.logger.info('Starting Agent {0}'.format(
cloudify_agent['name']))
installer.start_agent()
else:
# if remote_execution is False, and this operation was invoked
# (install_agent is True), it means that some other process is
# installing the agent (e.g userdata). All that is left for us
# to do is wait for the agent to start.
# celery is imported here since it's only used in this method
# and we can't assume it's always available
from cloudify_agent.app import app as celery_client
registered = utils.get_agent_registered(cloudify_agent['name'],
celery_client)
if registered:
ctx.logger.info('Agent has started')
else:
return ctx.operation.retry(
message='Waiting for Agent to start...')
else:
ctx.logger.info('Starting Agent {0}'.format(cloudify_agent['name']))
installer.start_agent()
def start(cloudify_agent, installer, **_):
if ctx.type == context.NODE_INSTANCE:
if cloudify_agent['remote_execution']:
ctx.logger.info('Starting Agent {0}'.format(
cloudify_agent['name']))
installer.start_agent()
else:
# if remote_execution is False, and this operation was invoked
# (install_agent is True), it means that some other process is
# installing the agent (e.g userdata). All that is left for us
# to do is wait for the agent to start.
# celery is imported here since it's only used in this method
# and we can't assume it's always available
from cloudify_agent.app import app as celery_client
registered = utils.get_agent_registered(cloudify_agent['name'],
celery_client)
if registered:
ctx.logger.info('Agent has started')
else:
return ctx.operation.retry(
message='Waiting for Agent to start...')
else:
ctx.logger.info('Starting Agent {0}'.format(cloudify_agent['name']))
installer.start_agent()
def reboot(nova_client, **_):
server = get_server_by_context(nova_client)
ctx.logger.info('Rebooting machine')
nova_client.servers.reboot(server)
i = 0
vm_started = False
while i < VM_ATTEMPTS and not vm_started:
ctx.logger.info('Waiting for vm to reboot, attempt {0}'.format(i + 1))
time.sleep(INTERVAL)
server = get_server_by_context(nova_client)
vm_started = server.status == SERVER_STATUS_ACTIVE
i += 1
if vm_started:
ctx.logger.info('Machine rebooted')
else:
raise NonRecoverableError('Could not reboot machine')
agent_name = ctx.instance.runtime_properties['cloudify_agent']['name']
i = 0
agent_alive = False
while i < AGENT_ATTEMPTS and not agent_alive:
ctx.logger.info('Waiting for agent, attempt {0}'.format(i + 1))
time.sleep(INTERVAL)
agent_alive = get_agent_registered(agent_name, app)
i += 1
if agent_alive:
ctx.logger.info('Agent started')
else:
raise NonRecoverableError('Agent did not start')
def reboot(nova_client, **_):
server = get_server_by_context(nova_client)
ctx.logger.info("Rebooting machine")
nova_client.servers.reboot(server)
i = 0
vm_started = False
while i < VM_ATTEMPTS and not vm_started:
ctx.logger.info("Waiting for vm to reboot, attempt {0}".format(i + 1))
time.sleep(INTERVAL)
server = get_server_by_context(nova_client)
vm_started = server.status == SERVER_STATUS_ACTIVE
i += 1
if vm_started:
ctx.logger.info("Machine rebooted")
else:
raise NonRecoverableError("Could not reboot machine")
agent_name = ctx.instance.runtime_properties["cloudify_agent"]["name"]
i = 0
agent_alive = False
while i < AGENT_ATTEMPTS and not agent_alive:
ctx.logger.info("Waiting for agent, attempt {0}".format(i + 1))
time.sleep(INTERVAL)
agent_alive = get_agent_registered(agent_name, app)
i += 1
if agent_alive:
ctx.logger.info("Agent started")
else:
raise NonRecoverableError("Agent did not start")
def _assert_agent_alive(name, celery_client, version=None):
tasks = utils.get_agent_registered(name, celery_client)
if not tasks:
raise NonRecoverableError(
'Could not access tasks list for agent {0}'.format(name))
task_name = _celery_task_name(version)
if task_name not in tasks:
raise NonRecoverableError(
'Task {0} is not available in agent {1}'.format(task_name, name))
def _assert_agent_alive(name, celery_client):
tasks = utils.get_agent_registered(name, celery_client)
if not tasks:
raise NonRecoverableError(
'Could not access tasks list for agent {0}'.format(name))
if 'script_runner.tasks.run' not in tasks:
raise NonRecoverableError(
('Task script_runner.tasks.run is not available in agent '
'{0}').format(name))
def _assert_agent_alive(name, celery_client):
tasks = utils.get_agent_registered(name, celery_client)
if not tasks:
raise NonRecoverableError(
'Could not access tasks list for agent {0}'.format(name))
if 'script_runner.tasks.run' not in tasks:
raise NonRecoverableError(
('Task script_runner.tasks.run is not available in agent '
'{0}').format(name))
def _assert_agent_alive(name, celery_client, version=None):
tasks = utils.get_agent_registered(name, celery_client)
if not tasks:
raise NonRecoverableError(
'Could not access tasks list for agent {0}'.format(name))
task_name = _celery_task_name(version)
if task_name not in tasks:
raise NonRecoverableError('Task {0} is not available in agent {1}'.
format(task_name, name))
def _is_agent_registered(self):
celery_client = utils.get_celery_client(
broker_url=self.broker_url,
ssl_enabled=self.broker_ssl_enabled,
ssl_cert_path=self._get_ssl_cert_path())
try:
self._logger.debug('Retrieving daemon registered tasks')
return utils.get_agent_registered(self.name, celery_client)
finally:
if celery_client:
celery_client.close()
def wait_for_daemon_dead(self, name, timeout=10):
deadline = time.time() + timeout
while time.time() < deadline:
registered = utils.get_agent_registered(name, self.celery)
if not registered:
return
self.logger.info('Waiting for daemon {0} to stop...'.format(name))
time.sleep(1)
raise RuntimeError('Failed waiting for daemon {0} to stop. Waited '
'for {1} seconds'.format(name, timeout))
def wait_for_daemon_dead(self, name, timeout=10):
deadline = time.time() + timeout
while time.time() < deadline:
registered = utils.get_agent_registered(name, self.celery)
if not registered:
return
self.logger.info('Waiting for daemon {0} to stop...'
.format(name))
time.sleep(1)
raise RuntimeError('Failed waiting for daemon {0} to stop. Waited '
'for {1} seconds'.format(name, timeout))
def start(cloudify_agent, **_):
"""
Only called in "init_script"/"plugin" mode, where the agent is started
externally (e.g. userdata script), and all we have to do is wait for it
"""
celery_client = get_celery_app(tenant=cloudify_agent['rest_tenant'],
target=cloudify_agent['queue'])
registered = utils.get_agent_registered(cloudify_agent['name'],
celery_client)
if registered:
ctx.logger.info('Agent has started')
else:
return ctx.operation.retry(message='Waiting for Agent to start...')
def _is_agent_registered(self):
celery_client = utils.get_celery_client(
broker_url=self.broker_url,
broker_ssl_enabled=self.broker_ssl_enabled,
broker_ssl_cert_path=self.broker_ssl_cert_path)
try:
self._logger.debug('Retrieving daemon registered tasks')
return utils.get_agent_registered(
self.name,
celery_client,
timeout=AGENT_IS_REGISTERED_TIMEOUT)
finally:
if celery_client:
celery_client.close()
def _is_agent_registered(self):
if self.cluster:
# only used for manager failures during installation - see
# detailed comment in the ._get_amqp_client method
celery_client = utils.get_cluster_celery_client(
self.broker_url, self.cluster)
else:
celery_client = utils.get_celery_client(
broker_url=self.broker_url,
broker_ssl_enabled=self.broker_ssl_enabled,
broker_ssl_cert_path=self.broker_ssl_cert_path)
try:
self._logger.debug('Retrieving daemon registered tasks')
return utils.get_agent_registered(
self.name, celery_client, timeout=AGENT_IS_REGISTERED_TIMEOUT)
finally:
if celery_client:
celery_client.close()
def _validate_celery(agent):
agent_name = agent['name']
agent_version = agent.get('version')
with _celery_app(agent) as celery_app:
broker_url = _conceal_amqp_password(celery_app.conf['BROKER_URL'])
ctx.logger.info(
'Checking if agent can be accessed through celery: {0}'
.format(broker_url))
tasks = utils.get_agent_registered(agent_name, celery_app)
# Using RecoverableError to allow retries
if not tasks:
raise RecoverableError(
'Could not access tasks list for agent {0}'.format(agent_name))
task_name = _celery_task_name(agent_version)
if task_name not in tasks:
raise RecoverableError('Task {0} is not available in agent {1}'.
format(task_name, agent_name))
return True
def _validate_celery(agent):
agent_name = agent['name']
agent_version = agent.get('version')
with _celery_app(agent) as celery_app:
broker_url = _conceal_amqp_password(celery_app.conf['BROKER_URL'])
ctx.logger.info(
'Checking if agent can be accessed through celery: {0}'
.format(broker_url))
tasks = utils.get_agent_registered(agent_name, celery_app)
# Using RecoverableError to allow retries
if not tasks:
raise RecoverableError(
'Could not access tasks list for agent {0}'.format(agent_name))
task_name = _celery_task_name(agent_version)
if task_name not in tasks:
raise RecoverableError('Task {0} is not available in agent {1}'.
format(task_name, agent_name))
return True
def assert_daemon_dead(self, name):
registered = utils.get_agent_registered(name, self.celery)
self.assertTrue(registered is None)
def assert_daemon_dead(self, name):
registered = utils.get_agent_registered(name, self.celery)
self.assertTrue(registered is None)
