def node_update(context, node_id, values): '''Update a node with new property values. :param node_id: ID of the node to be updated. :param values: A dictionary of values to be updated on the node. :raises ClusterNotFound: The specified node does not exist in database. ''' with session_for_write() as session: node = session.query(models.Node).get(node_id) if not node: raise exception.NodeNotFound(node=node_id) node.update(values) node.save(session) if 'status' in values and node.cluster_id is not None: cluster = session.query(models.Cluster).get(node.cluster_id) if cluster is not None: if values['status'] == 'ERROR': cluster.status = 'WARNING' if 'status_reason' in values: cluster.status_reason = _('Node %(node)s: %(reason)s') % { 'node': node.name, 'reason': values['status_reason'] } cluster.save(session)
def test_local_error_name(self): ex = exception.NodeNotFound(node='A') self.assertEqual('NodeNotFound', self.rpcapi.local_error_name(ex)) exr = self._to_remote_error(ex) self.assertEqual('NodeNotFound_Remote', exr.__class__.__name__) self.assertEqual('NodeNotFound', self.rpcapi.local_error_name(exr))
def test_node_action_join_node_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) node_id = 'unknown-node' cluster_id = 'existing_cluster' body = { 'join': { 'cluster_id': cluster_id, } } req = self._put('/nodes/%(node_id)s/action' % {'node_id': node_id}, json.dumps(body)) error = senlin_exc.NodeNotFound(node=node_id) mock_call = self.patchobject(rpc_client.EngineClient, 'call') mock_call.side_effect = shared.to_remote_error(error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.action, req, tenant_id=self.project, node_id=node_id, body=body) self.assertEqual(404, resp.json['code']) self.assertEqual('NodeNotFound', resp.json['error']['type'])
def load(cls, context, node_id=None, node=None, project_safe=True): '''Retrieve a node from database.''' if node is None: node = db_api.node_get(context, node_id, project_safe=project_safe) if node is None: raise exception.NodeNotFound(node=node_id) return cls._from_db_record(context, node)
def load(cls, context, node_id=None, node=None, show_deleted=False): '''Retrieve a node from database.''' if node is None: node = db_api.node_get(context, node_id, show_deleted=show_deleted) if node is None: raise exception.NodeNotFound(node=node_id) return cls._from_db_record(context, node)
def load(cls, context, node_id=None, db_node=None, project_safe=True): '''Retrieve a node from database.''' if db_node is None: db_node = no.Node.get(context, node_id, project_safe=project_safe) if db_node is None: raise exception.NodeNotFound(node=node_id) return cls._from_object(context, db_node)
def test_node_recover_not_found(self, mock_find): mock_find.side_effect = exc.NodeNotFound(node='Bogus') ex = self.assertRaises(rpc.ExpectedException, self.eng.node_recover, self.ctx, 'Bogus') self.assertEqual(exc.NodeNotFound, ex.exc_info[0]) self.assertEqual('The node (Bogus) could not be found.', six.text_type(ex.exc_info[1])) mock_find.assert_called_once_with(self.ctx, 'Bogus')
def test_ignore_error_named(self): ex = exception.NodeNotFound(node='A') exr = self._to_remote_error(ex) self.rpcapi.ignore_error_named(ex, 'NodeNotFound') self.rpcapi.ignore_error_named(exr, 'NodeNotFound') self.assertRaises(exception.NodeNotFound, self.rpcapi.ignore_error_named, ex, 'NotSupported') self.assertRaises(exception.NodeNotFound, self.rpcapi.ignore_error_named, exr, 'NotSupported')
def test_node_delete_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'delete', True) nid = 'aaaa-bbbb-cccc' req = self._delete('/nodes/%(node_id)s' % {'node_id': nid}) error = senlin_exc.NodeNotFound(node=nid) mock_call = self.patchobject(rpc_client.EngineClient, 'call') mock_call.side_effect = shared.to_remote_error(error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.delete, req, node_id=nid) self.assertEqual(404, resp.json['code']) self.assertEqual('NodeNotFound', resp.json['error']['type'])
def test_node_get_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'get', True) node_id = 'non-existent-node' req = self._get('/nodes/%(node_id)s' % {'node_id': node_id}) error = senlin_exc.NodeNotFound(node=node_id) mock_call = self.patchobject(rpc_client.EngineClient, 'call') mock_call.side_effect = shared.to_remote_error(error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.get, req, tenant_id=self.project, node_id=node_id) self.assertEqual(404, resp.json['code']) self.assertEqual('NodeNotFound', resp.json['error']['type'])
def test_node_action_recover_node_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) node_id = 'xxxx-yyyy' body = {'recover': {}} req = self._post('/nodes/%(node_id)s/actions' % {'node_id': node_id}, jsonutils.dumps(body)) error = senlin_exc.NodeNotFound(node=node_id) mock_call = self.patchobject(rpc_client.EngineClient, 'call') mock_call.side_effect = shared.to_remote_error(error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.action, req, node_id=node_id, body=body) self.assertEqual(404, resp.json['code']) self.assertEqual('NodeNotFound', resp.json['error']['type']) mock_call.assert_called_once_with( req.context, ('node_recover', {'identity': node_id, 'params': {}}))
def test_node_update_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'update', True) nid = 'non-exist-node' body = { 'node': { 'name': 'test_node', 'profile_id': 'xxxx-yyyy', 'role': None, 'metadata': {}, } } req = self._patch('/nodes/%(node_id)s' % {'node_id': nid}, json.dumps(body)) error = senlin_exc.NodeNotFound(node=nid) mock_call = self.patchobject(rpc_client.EngineClient, 'call', side_effect=shared.to_remote_error(error)) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.update, req, tenant_id=self.project, node_id=nid, body=body) mock_call.assert_called_with(req.context, ('node_update', { 'identity': nid, 'name': 'test_node', 'profile_id': 'xxxx-yyyy', 'role': None, 'metadata': {}, })) self.assertEqual(404, resp.json['code']) self.assertEqual('NodeNotFound', resp.json['error']['type'])