def rc_delete(self, context, rc_ident, bay_ident): LOG.debug("rc_delete %s", rc_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. if not utils.is_uuid_like(bay_ident): bay = objects.Bay.get_by_name(context, bay_ident) bay_ident = bay.uuid bay_uuid = bay_ident self.k8s_api = k8s.create_k8s_api_rc(context, bay_uuid) if utils.is_uuid_like(rc_ident): rc = objects.ReplicationController.get_by_uuid(context, rc_ident, bay_uuid, self.k8s_api) rc_name = rc.name else: rc_name = rc_ident if conductor_utils.object_has_stack(context, bay_uuid): try: self.k8s_api.delete_namespaced_replication_controller( name=str(rc_name), body={}, namespace='default') except rest.ApiException as err: if err.status == 404: pass else: raise exception.KubernetesAPIFailed(err=err)
def service_update(self, context, service_ident, bay_ident, manifest): LOG.debug("service_update %s", service_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. if not utils.is_uuid_like(bay_ident): bay = objects.Bay.get_by_name(context, bay_ident) bay_ident = bay.uuid bay_uuid = bay_ident self.k8s_api = k8s.create_k8s_api_service(context, bay_uuid) if utils.is_uuid_like(service_ident): service = objects.Service.get_by_uuid(context, service_ident, bay_uuid, self.k8s_api) else: service = objects.Service.get_by_name(context, service_ident, bay_uuid, self.k8s_api) service_ident = service.name try: resp = self.k8s_api.replace_namespaced_service( name=str(service_ident), body=manifest, namespace='default') except rest.ApiException as err: raise exception.KubernetesAPIFailed(err=err) if resp is None: raise exception.ServiceNotFound(service=service.uuid) service['uuid'] = resp.metadata.uid service['name'] = resp.metadata.name service['project_id'] = context.project_id service['user_id'] = context.user_id service['bay_uuid'] = bay_uuid service['labels'] = ast.literal_eval(resp.metadata.labels) if not resp.spec.selector: service['selector'] = {} else: service['selector'] = ast.literal_eval(resp.spec.selector) service['ip'] = resp.spec.cluster_ip service_value = [] for p in resp.spec.ports: ports = p.to_dict() if not ports['name']: ports['name'] = 'k8s-service' service_value.append(ports) service['ports'] = service_value return service
def pod_update(self, context, pod_ident, bay_ident, manifest): LOG.debug("pod_update %s", pod_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(pod_ident): pod = objects.Pod.get_by_uuid(context, pod_ident, bay.uuid, self.k8s_api) else: pod = objects.Pod.get_by_name(context, pod_ident, bay.uuid, self.k8s_api) pod_ident = pod.name try: resp = self.k8s_api.replace_namespaced_pod(name=str(pod_ident), body=manifest, namespace='default') except rest.ApiException as err: raise exception.KubernetesAPIFailed(err=err) if resp is None: raise exception.PodNotFound(pod=pod.uuid) pod['uuid'] = resp.metadata.uid pod['name'] = resp.metadata.name pod['project_id'] = context.project_id pod['user_id'] = context.user_id pod['bay_uuid'] = bay.uuid pod['images'] = [c.image for c in resp.spec.containers] if not resp.metadata.labels: pod['labels'] = {} else: pod['labels'] = ast.literal_eval(resp.metadata.labels) pod['status'] = resp.status.phase pod['host'] = resp.spec.node_name return pod
def test_create_baymodel_generate_uuid(self, mock_image_data): mock_image_data.return_value = {"name": "mock_name", "os_distro": "fedora-atomic"} bdict = apiutils.baymodel_post_data() del bdict["uuid"] response = self.post_json("/baymodels", bdict) self.assertEqual(bdict["image_id"], response.json["image_id"]) self.assertTrue(utils.is_uuid_like(response.json["uuid"]))
def _test_create_baymodel_network_driver_attr(self, baymodel_dict, baymodel_config_dict, expect_errors, mock_keypair_exists, mock_image_data): mock_keypair_exists.return_value = None mock_image_data.return_value = { 'name': 'mock_name', 'os_distro': 'fedora-atomic' } for k, v in baymodel_config_dict.items(): cfg.CONF.set_override(k, v, 'baymodel') with mock.patch.object(self.dbapi, 'create_baymodel', wraps=self.dbapi.create_baymodel) as cc_mock: bdict = apiutils.baymodel_post_data(**baymodel_dict) response = self.post_json('/baymodels', bdict, expect_errors=expect_errors) if expect_errors: self.assertEqual(400, response.status_int) else: expected_driver = bdict.get('network_driver') if not expected_driver: expected_driver = ( cfg.CONF.baymodel.swarm_default_network_driver) self.assertEqual(expected_driver, response.json['network_driver']) self.assertEqual(bdict['image_id'], response.json['image_id']) cc_mock.assert_called_once_with(mock.ANY) self.assertNotIn('id', cc_mock.call_args[0][0]) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_generate_uuid(self): cdict = apiutils.baymodel_post_data() del cdict['uuid'] response = self.post_json('/baymodels', cdict) self.assertEqual(cdict['image_id'], response.json['image_id']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_with_no_network_driver(self, mock_keypair_exists, mock_image_data): mock_keypair_exists.return_value = None with mock.patch.object(self.dbapi, 'create_baymodel', wraps=self.dbapi.create_baymodel) as cc_mock: mock_image_data.return_value = { 'name': 'mock_name', 'os_distro': 'fedora-atomic' } bdict = apiutils.baymodel_post_data() response = self.post_json('/baymodels', bdict) self.assertEqual(bdict['network_driver'], response.json['network_driver']) cc_mock.assert_called_once_with(mock.ANY) self.assertNotIn('id', cc_mock.call_args[0][0]) mock_image_data.return_value = { 'name': 'mock_name', 'os_distro': 'fedora-atomic' } bdict = apiutils.baymodel_post_data() del bdict['uuid'] response = self.post_json('/baymodels', bdict) self.assertEqual(bdict['image_id'], response.json['image_id']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def rc_update(self, context, rc_ident, bay_ident, manifest): LOG.debug("rc_update %s", rc_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(rc_ident): rc = objects.ReplicationController.get_by_uuid( context, rc_ident, bay.uuid, self.k8s_api) else: rc = objects.ReplicationController.get_by_name( context, rc_ident, bay.uuid, self.k8s_api) try: resp = self.k8s_api.replace_namespaced_replication_controller( name=str(rc.name), body=manifest, namespace='default') except rest.ApiException as err: raise exception.KubernetesAPIFailed(err=err) if resp is None: raise exception.ReplicationControllerNotFound(rc=rc.uuid) rc['uuid'] = resp.metadata.uid rc['name'] = resp.metadata.name rc['project_id'] = context.project_id rc['user_id'] = context.user_id rc['images'] = [c.image for c in resp.spec.template.spec.containers] rc['bay_uuid'] = bay.uuid rc['labels'] = ast.literal_eval(resp.metadata.labels) rc['replicas'] = resp.status.replicas return rc
def get_openstack_resource(manager, resource_ident, resource_type): """Get the openstack resource from the uuid or logical name. :param manager: the resource manager class. :param resource_ident: the UUID or logical name of the resource. :param resource_type: the type of the resource :returns: The openstack resource. :raises: ResourceNotFound if the openstack resource is not exist. Conflict if multi openstack resources have same name. """ if utils.is_uuid_like(resource_ident): resource_data = manager.get(resource_ident) else: filters = {'name': resource_ident} matches = list(manager.list(filters=filters)) if len(matches) == 0: raise exception.ResourceNotFound(name=resource_type, id=resource_ident) if len(matches) > 1: msg = ("Multiple '%s' exist with same name '%s'. " "Please use the resource id instead." % (resource_type, resource_ident)) raise exception.Conflict(msg) resource_data = matches[0] return resource_data
def rc_update(self, context, rc_ident, bay_ident, manifest): LOG.debug("rc_update %s", rc_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(rc_ident): rc = objects.ReplicationController.get_by_uuid(context, rc_ident, bay.uuid, self.k8s_api) else: rc = objects.ReplicationController.get_by_name(context, rc_ident, bay.uuid, self.k8s_api) try: resp = self.k8s_api.replace_namespaced_replication_controller( name=str(rc.name), body=manifest, namespace='default') except rest.ApiException as err: raise exception.KubernetesAPIFailed(err=err) if resp is None: raise exception.ReplicationControllerNotFound(rc=rc.uuid) rc['uuid'] = resp.metadata.uid rc['name'] = resp.metadata.name rc['project_id'] = context.project_id rc['user_id'] = context.user_id rc['images'] = [c.image for c in resp.spec.template.spec.containers] rc['bay_uuid'] = bay.uuid rc['labels'] = ast.literal_eval(resp.metadata.labels) rc['replicas'] = resp.status.replicas return rc
def _test_create_baymodel_network_driver_attr(self, baymodel_dict, baymodel_config_dict, expect_errors, mock_keypair_exists, mock_image_data): mock_keypair_exists.return_value = None mock_image_data.return_value = {'name': 'mock_name', 'os_distro': 'fedora-atomic'} for k, v in baymodel_config_dict.items(): cfg.CONF.set_override(k, v, 'baymodel') with mock.patch.object(self.dbapi, 'create_baymodel', wraps=self.dbapi.create_baymodel) as cc_mock: bdict = apiutils.baymodel_post_data(**baymodel_dict) response = self.post_json('/baymodels', bdict, expect_errors=expect_errors) if expect_errors: self.assertEqual(400, response.status_int) else: expected_driver = bdict.get('network_driver') if not expected_driver: expected_driver = ( cfg.CONF.baymodel.swarm_default_network_driver) self.assertEqual(expected_driver, response.json['network_driver']) self.assertEqual(bdict['image_id'], response.json['image_id']) cc_mock.assert_called_once_with(mock.ANY) self.assertNotIn('id', cc_mock.call_args[0][0]) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_service_generate_uuid(self): sdict = apiutils.service_post_data() del sdict['uuid'] response = self.post_json('/services', sdict) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_generate_uuid(self, mock_image_data): mock_image_data.return_value = {'name': 'mock_name', 'os_distro': 'fedora-atomic'} bdict = apiutils.baymodel_post_data() del bdict['uuid'] response = self.post_json('/baymodels', bdict) self.assertEqual(bdict['image_id'], response.json['image_id']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_node_generate_uuid(self): node_dict = apiutils.node_post_data() del node_dict['uuid'] response = self.post_json('/nodes', node_dict) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(node_dict['image_id'], response.json['image_id']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_service_generate_uuid(self, mock_service_create): sdict = apiutils.service_post_data() del sdict["uuid"] mock_service_create.return_value = self.service_obj response = self.post_json("/services", sdict, expect_errors=True) self.assertEqual("application/json", response.content_type) self.assertEqual(201, response.status_int) self.assertTrue(utils.is_uuid_like(response.json["uuid"]))
def test_create_x509keypair_generate_uuid(self): cdict = apiutils.x509keypair_post_data() del cdict['uuid'] response = self.post_json('/x509keypairs', cdict) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(cdict['name'], response.json['name']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_bay_generate_uuid(self): bdict = apiutils.bay_post_data() del bdict['uuid'] response = self.post_json('/bays', bdict) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(bdict['name'], response.json['name']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_pod_generate_uuid(self): pdict = apiutils.pod_post_data() del pdict['uuid'] response = self.post_json('/pods', pdict) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(pdict['desc'], response.json['desc']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_rc_generate_uuid(self): rc_dict = apiutils.rc_post_data() del rc_dict['uuid'] response = self.post_json('/rcs', rc_dict) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(rc_dict['images'], response.json['images']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_service_generate_uuid(self, mock_service_create): sdict = apiutils.service_post_data() del sdict['uuid'] mock_service_create.return_value = self.service_obj response = self.post_json('/services', sdict, expect_errors=True) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_rc_generate_uuid(self, mock_rc_create): rc_dict = apiutils.rc_post_data() del rc_dict['uuid'] mock_rc_create.return_value = self.rc_obj response = self.post_json('/rcs', rc_dict, expect_errors=True) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(rc_dict['images'], response.json['images']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def pod_show(self, context, pod_ident, bay_ident): LOG.debug("pod_show %s", pod_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. if not utils.is_uuid_like(bay_ident): bay = objects.Bay.get_by_name(context, bay_ident) bay_ident = bay.uuid bay_uuid = bay_ident self.k8s_api = k8s.create_k8s_api_pod(context, bay_uuid) if utils.is_uuid_like(pod_ident): pod = objects.Pod.get_by_uuid(context, pod_ident, bay_uuid, self.k8s_api) else: pod = objects.Pod.get_by_name(context, pod_ident, bay_uuid, self.k8s_api) return pod
def test_create_pod_generate_uuid(self, mock_pod_create): pdict = apiutils.pod_post_data() del pdict['uuid'] mock_pod_create.return_value = self.pod_obj response = self.post_json('/pods', pdict, expect_errors=True) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(pdict['desc'], response.json['desc']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_baymodel_generate_uuid(self, mock_image_data): mock_image_data.return_value = { 'name': 'mock_name', 'os_distro': 'fedora-atomic' } bdict = apiutils.baymodel_post_data() del bdict['uuid'] response = self.post_json('/baymodels', bdict) self.assertEqual(bdict['image_id'], response.json['image_id']) self.assertTrue(utils.is_uuid_like(response.json['uuid']))
def test_create_bay_generate_uuid(self, mock_valid_os_res): bdict = apiutils.bay_post_data() del bdict["uuid"] mock_valid_os_res.return_value = None response = self.post_json("/bays", bdict) self.assertEqual("application/json", response.content_type) self.assertEqual(201, response.status_int) self.assertEqual(bdict["name"], response.json["name"]) self.assertTrue(utils.is_uuid_like(response.json["uuid"]))
def pod_update(self, context, pod_ident, bay_ident, manifest): LOG.debug("pod_update %s", pod_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. if not utils.is_uuid_like(bay_ident): bay = objects.Bay.get_by_name(context, bay_ident) bay_ident = bay.uuid bay_uuid = bay_ident self.k8s_api = k8s.create_k8s_api_pod(context, bay_uuid) if utils.is_uuid_like(pod_ident): pod = objects.Pod.get_by_uuid(context, pod_ident, bay_uuid, self.k8s_api) else: pod = objects.Pod.get_by_name(context, pod_ident, bay_uuid, self.k8s_api) pod_ident = pod.name try: resp = self.k8s_api.replace_namespaced_pod(name=str(pod_ident), body=manifest, namespace='default') except rest.ApiException as err: raise exception.KubernetesAPIFailed(err=err) if resp is None: raise exception.PodNotFound(pod=pod.uuid) pod['uuid'] = resp.metadata.uid pod['name'] = resp.metadata.name pod['project_id'] = context.project_id pod['user_id'] = context.user_id pod['bay_uuid'] = bay_uuid pod['images'] = [c.image for c in resp.spec.containers] if not resp.metadata.labels: pod['labels'] = {} else: pod['labels'] = ast.literal_eval(resp.metadata.labels) pod['status'] = resp.status.phase pod['host'] = resp.spec.node_name return pod
def rc_show(self, context, rc_ident, bay_ident): LOG.debug("rc_show %s", rc_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(rc_ident): rc = objects.ReplicationController.get_by_uuid( context, rc_ident, bay.uuid, self.k8s_api) else: rc = objects.ReplicationController.get_by_name( context, rc_ident, bay.uuid, self.k8s_api) return rc
def service_show(self, context, service_ident, bay_ident): LOG.debug("service_show %s", service_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(service_ident): service = objects.Service.get_by_uuid(context, service_ident, bay.uuid, self.k8s_api) else: service = objects.Service.get_by_name(context, service_ident, bay.uuid, self.k8s_api) return service
def rc_show(self, context, rc_ident, bay_ident): LOG.debug("rc_show %s", rc_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. if not utils.is_uuid_like(bay_ident): bay = objects.Bay.get_by_name(context, bay_ident) bay_ident = bay.uuid bay_uuid = bay_ident self.k8s_api = k8s.create_k8s_api_rc(context, bay_uuid) if utils.is_uuid_like(rc_ident): rc = objects.ReplicationController.get_by_uuid(context, rc_ident, bay_uuid, self.k8s_api) else: rc = objects.ReplicationController.get_by_name(context, rc_ident, bay_uuid, self.k8s_api) return rc
def get(cls, context, node_id): """Find a node based on its id or uuid and return a Node object. :param node_id: the id *or* uuid of a node. :returns: a :class:`Node` object. """ if utils.is_int_like(node_id): return cls.get_by_id(context, node_id) elif utils.is_uuid_like(node_id): return cls.get_by_uuid(context, node_id) else: raise exception.InvalidIdentity(identity=node_id)
def get(cls, context, pod_id): """Find a pod based on its id or uuid and return a Pod object. :param pod_id: the id *or* uuid of a pod. :returns: a :class:`Pod` object. """ if utils.is_int_like(pod_id): return cls.get_by_id(context, pod_id) elif utils.is_uuid_like(pod_id): return cls.get_by_uuid(context, pod_id) else: raise exception.InvalidIdentity(identity=pod_id)
def pod_show(self, context, pod_ident, bay_ident): LOG.debug("pod_show %s", pod_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(pod_ident): pod = objects.Pod.get_by_uuid(context, pod_ident, bay.uuid, self.k8s_api) else: pod = objects.Pod.get_by_name(context, pod_ident, bay.uuid, self.k8s_api) return pod
def get(cls, context, service_id): """Find a service based on its id or uuid and return a Service object. :param service_id: the id *or* uuid of a service. :returns: a :class:`Service` object. """ if utils.is_int_like(service_id): return cls.get_by_id(context, service_id) elif utils.is_uuid_like(service_id): return cls.get_by_uuid(context, service_id) else: raise exception.InvalidIdentity(identity=service_id)
def get(cls, context, baymodel_id): """Find a baymodel based on its id or uuid and return a BayModel object. :param baymodel_id: the id *or* uuid of a baymodel. :returns: a :class:`BayModel` object. """ if utils.is_int_like(baymodel_id): return cls.get_by_id(context, baymodel_id) elif utils.is_uuid_like(baymodel_id): return cls.get_by_uuid(context, baymodel_id) else: raise exception.InvalidIdentity(identity=baymodel_id)
def get(cls, context, bay_id): """Find a bay based on its id or uuid and return a Bay object. :param bay_id: the id *or* uuid of a bay. :returns: a :class:`Bay` object. """ if utils.is_int_like(bay_id): return cls.get_by_id(context, bay_id) elif utils.is_uuid_like(bay_id): return cls.get_by_uuid(context, bay_id) else: raise exception.InvalidIdentity(identity=bay_id)
def rc_update(self, context, rc_ident, bay_ident, manifest): LOG.debug("rc_update %s", rc_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. if not utils.is_uuid_like(bay_ident): bay = objects.Bay.get_by_name(context, bay_ident) bay_ident = bay.uuid bay_uuid = bay_ident self.k8s_api = k8s.create_k8s_api_rc(context, bay_uuid) if utils.is_uuid_like(rc_ident): rc = objects.ReplicationController.get_by_uuid(context, rc_ident, bay_uuid, self.k8s_api) else: rc = objects.ReplicationController.get_by_name(context, rc_ident, bay_uuid, self.k8s_api) try: resp = self.k8s_api.replace_namespaced_replication_controller( name=str(rc.name), body=manifest, namespace='default') except rest.ApiException as err: raise exception.KubernetesAPIFailed(err=err) if resp is None: raise exception.ReplicationControllerNotFound(rc=rc.uuid) rc['uuid'] = resp.metadata.uid rc['name'] = resp.metadata.name rc['project_id'] = context.project_id rc['user_id'] = context.user_id rc['images'] = [c.image for c in resp.spec.template.spec.containers] rc['bay_uuid'] = bay_uuid rc['labels'] = ast.literal_eval(resp.metadata.labels) rc['replicas'] = resp.status.replicas return rc
def get(cls, context, x509keypair_id): """Find a x509keypair_id based on its id or uuid and return a X509KeyPair object. :param x509keypair_id: the id *or* uuid of a x509keypair. :returns: a :class:`X509KeyPair` object. """ if utils.is_int_like(x509keypair_id): return cls.get_by_id(context, x509keypair_id) elif utils.is_uuid_like(x509keypair_id): return cls.get_by_uuid(context, x509keypair_id) else: raise exception.InvalidIdentity(identity=x509keypair_id)
def get_service_by_instance(self, instance): if not utils.is_uuid_like(instance): raise exception.InvalidUUID(uuid=instance) query = (model_query(models.Service) .filter_by(instance_uuid=instance)) try: result = query.one() except NoResultFound: raise exception.InstanceNotFound(instance=instance) return result
def get_rpc_resource(resource, resource_ident): """Get the RPC resource from the uuid or logical name. :param resource: the resource type. :param resource_ident: the UUID or logical name of the resource. :returns: The RPC resource. """ resource = getattr(objects, resource) if utils.is_uuid_like(resource_ident): return resource.get_by_uuid(pecan.request.context, resource_ident) return resource.get_by_name(pecan.request.context, resource_ident)
def pod_show(self, context, pod_ident, bay_ident): LOG.debug("pod_show %s", pod_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. bay_uuid = conductor_utils.retrieve_bay_uuid(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay_uuid) if utils.is_uuid_like(pod_ident): pod = objects.Pod.get_by_uuid(context, pod_ident, bay_uuid, self.k8s_api) else: pod = objects.Pod.get_by_name(context, pod_ident, bay_uuid, self.k8s_api) return pod
def add_identity_filter(query, value): """Adds an identity filter to a query. Filters results by ID, if supplied value is a valid integer. Otherwise attempts to filter results by UUID. :param query: Initial query to add filter to. :param value: Value for filtering results by. :return: Modified query. """ if utils.is_int_like(value): return query.filter_by(id=value) elif utils.is_uuid_like(value): return query.filter_by(uuid=value) else: raise exception.InvalidIdentity(identity=value)
def get_rpc_resource(resource, resource_ident): """Get the RPC resource from the uuid or logical name. :param resource: the resource type. :param resource_ident: the UUID or logical name of the resource. :returns: The RPC resource. :raises: InvalidUuidOrName if the name or uuid provided is not valid. """ resource = getattr(objects, resource) if utils.is_uuid_like(resource_ident): return resource.get_by_uuid(pecan.request.context, resource_ident) if utils.allow_logical_names(): return resource.get_by_name(pecan.request.context, resource_ident) raise exception.InvalidUuidOrName(name=resource_ident)
def service_update(self, context, service_ident, bay_ident, manifest): LOG.debug("service_update %s", service_ident) # Since bay identifier is specified verify whether its a UUID # or Name. If name is specified as bay identifier need to extract # the bay uuid since its needed to get the k8s_api object. bay_uuid = conductor_utils.retrieve_bay_uuid(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay_uuid) if utils.is_uuid_like(service_ident): service = objects.Service.get_by_uuid(context, service_ident, bay_uuid, self.k8s_api) else: service = objects.Service.get_by_name(context, service_ident, bay_uuid, self.k8s_api) service_ident = service.name try: resp = self.k8s_api.replace_namespaced_service( name=str(service_ident), body=manifest, namespace='default') except rest.ApiException as err: raise exception.KubernetesAPIFailed(err=err) if resp is None: raise exception.ServiceNotFound(service=service.uuid) service['uuid'] = resp.metadata.uid service['name'] = resp.metadata.name service['project_id'] = context.project_id service['user_id'] = context.user_id service['bay_uuid'] = bay_uuid service['labels'] = ast.literal_eval(resp.metadata.labels) if not resp.spec.selector: service['selector'] = {} else: service['selector'] = ast.literal_eval(resp.spec.selector) service['ip'] = resp.spec.cluster_ip service_value = [] for p in resp.spec.ports: ports = p.to_dict() if not ports['name']: ports['name'] = 'k8s-service' service_value.append(ports) service['ports'] = service_value return service
def rc_delete(self, context, rc_ident, bay_ident): LOG.debug("rc_delete %s", rc_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(rc_ident): rc = objects.ReplicationController.get_by_uuid( context, rc_ident, bay.uuid, self.k8s_api) rc_name = rc.name else: rc_name = rc_ident if conductor_utils.object_has_stack(context, bay.uuid): try: self.k8s_api.delete_namespaced_replication_controller( name=str(rc_name), body={}, namespace='default') except rest.ApiException as err: if err.status == 404: pass else: raise exception.KubernetesAPIFailed(err=err)
def service_delete(self, context, service_ident, bay_ident): LOG.debug("service_delete %s", service_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(service_ident): service = objects.Service.get_by_uuid(context, service_ident, bay.uuid, self.k8s_api) service_name = service.name else: service_name = service_ident if conductor_utils.object_has_stack(context, bay.uuid): try: self.k8s_api.delete_namespaced_service(name=str(service_name), namespace='default') except rest.ApiException as err: if err.status == 404: pass else: raise exception.KubernetesAPIFailed(err=err)
def pod_delete(self, context, pod_ident, bay_ident): LOG.debug("pod_delete %s", pod_ident) bay = conductor_utils.retrieve_bay(context, bay_ident) self.k8s_api = k8s.create_k8s_api(context, bay) if utils.is_uuid_like(pod_ident): pod = objects.Pod.get_by_uuid(context, pod_ident, bay.uuid, self.k8s_api) pod_name = pod.name else: pod_name = pod_ident if conductor_utils.object_has_stack(context, bay.uuid): try: self.k8s_api.delete_namespaced_pod(name=str(pod_name), body={}, namespace='default') except rest.ApiException as err: if err.status == 404: pass else: raise exception.KubernetesAPIFailed(err=err)