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, 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 assert_daemon_dead(self, name): registered = utils.get_agent_registered(name, self.celery) self.assertTrue(registered is None)