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 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 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 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 _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_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 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_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 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 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, 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 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 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 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 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(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)
