def test_replication_controller_apis(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apiv_api.ApivApi(client)
rc_manifest = {
'apiVersion': 'v1',
'kind': 'ReplicationController',
'metadata': {'labels': {'name': 'frontend'},
'name': 'frontend'},
'spec': {'replicas': 2,
'selector': {'name': 'frontend'},
'template': {'metadata': {
'labels': {'name': 'frontend'}},
'spec': {'containers': [{
'image': 'nginx',
'name': 'nginx',
'ports': [{'containerPort': 80,
'protocol': 'TCP'}]}]}}}}
resp = api.create_namespaced_replication_controller(
body=rc_manifest, namespace='default')
self.assertEqual('frontend', resp.metadata.name)
self.assertEqual(2, resp.spec.replicas)
resp = api.read_namespaced_replication_controller(
name='frontend', namespace='default')
self.assertEqual('frontend', resp.metadata.name)
self.assertEqual(2, resp.spec.replicas)
resp = api.delete_namespaced_replication_controller(
name='frontend', body={}, namespace='default')
def test_configmap_apis(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apiv_api.ApivApi(client)
test_configmap = {
"kind": "ConfigMap",
"apiVersion": "v1",
"metadata": {
"name": "test-configmap",
},
"data": {
"config.json": "{\"command\":\"/usr/bin/mysqld_safe\"}",
"frontend.cnf": "[mysqld]\nbind-address = 10.0.0.3\nport = 3306\n"
}
}
resp = api.create_namespaced_config_map(
body=test_configmap, namespace='default'
)
self.assertEqual('test-configmap', resp.metadata.name)
resp = api.read_namespaced_config_map(
name='test-configmap', namespace='default')
self.assertEqual('test-configmap', resp.metadata.name)
test_configmap['data']['config.json'] = "{}"
resp = api.patch_namespaced_config_map(
name='test-configmap', namespace='default', body=test_configmap)
resp = api.delete_namespaced_config_map(
name='test-configmap', body={}, namespace='default')
def test_pod_apis(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apiv_api.ApivApi(client)
name = 'test-' + str(uuid.uuid4())
pod_manifest = {'apiVersion': 'v1',
'kind': 'Pod',
'metadata': {'color': 'blue', 'name': name},
'spec': {'containers': [{'image': 'dockerfile/redis',
'name': 'redis'}]}}
resp = api.create_namespaced_pod(body=pod_manifest,
namespace='default')
self.assertEqual(name, resp.metadata.name)
self.assertTrue(resp.status.phase)
resp = api.read_namespaced_pod(name=name,
namespace='default')
self.assertEqual(name, resp.metadata.name)
self.assertTrue(resp.status.phase)
number_of_pods = len(api.list_pod().items)
self.assertTrue(number_of_pods > 0)
resp = api.delete_namespaced_pod(name=name, body={},
namespace='default')
def list_RC():
client = api_client.ApiClient(k8s_url)
api = apiv_api.ApivApi(client)
rcs = api.list_namespaced_replication_controller(namespace='default')
# print("RC数量：" + str(len(rcs.items)))
print(rcs)
def list_SVC():
client = api_client.ApiClient(k8s_url)
api = apiv_api.ApivApi(client)
svcs = api.list_namespaced_service(namespace='default')
# print "service数量：" + str(len(svcs.items))
print(svcs)
def test_job_apis(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apisbatchv_api.ApisbatchvApi(client)
job_manifest = {
'kind': 'Job',
'spec': {
'template':
{'spec':
{'containers': [
{'image': 'busybox',
'name': 'test-job',
'command': ["sh", "-c", "sleep 5"]
}],
'restartPolicy': 'Never'},
'metadata': {'name': 'test-job'}}},
'apiVersion': 'batch/v1',
'metadata': {'name': 'test-job'}}
resp = api.create_namespaced_job(
body=job_manifest, namespace='default')
self.assertEqual('test-job', resp.metadata.name)
resp = api.read_namespaced_job(
name='test-job', namespace='default')
self.assertEqual('test-job', resp.metadata.name)
resp = api.delete_namespaced_job(
name='test-job', body={}, namespace='default')
def test_service_apis(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apiv_api.ApivApi(client)
service_manifest = {'apiVersion': 'v1',
'kind': 'Service',
'metadata': {'labels': {'name': 'frontend'},
'name': 'frontend',
'resourceversion': 'v1'},
'spec': {'ports': [{'port': 80,
'protocol': 'TCP',
'targetPort': 80}],
'selector': {'name': 'frontend'}}}
resp = api.create_namespaced_service(body=service_manifest,
namespace='default')
self.assertEqual('frontend', resp.metadata.name)
self.assertTrue(resp.status)
resp = api.read_namespaced_service(name='frontend',
namespace='default')
self.assertEqual('frontend', resp.metadata.name)
self.assertTrue(resp.status)
resp = api.delete_namespaced_service(name='frontend',
namespace='default')
def test_node_apis(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apiv_api.ApivApi(client)
for item in api.list_namespaced_node().items:
node = api.read_namespaced_node(name=item.metadata.name)
self.assertTrue(len(node.metadata.labels) > 0)
self.assertIsInstance(node.metadata.labels, dict)
def setUpClass(cls):
super(BaseK8sTest, cls).setUpClass()
cls.kube_api_url = cls.cs.bays.get(cls.bay.uuid).api_address
k8s_client = api_client.ApiClient(cls.kube_api_url,
key_file=cls.key_file,
cert_file=cls.cert_file,
ca_certs=cls.ca_file)
cls.k8s_api = apiv_api.ApivApi(k8s_client)
def test_list_nodes_and_endpoints(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apiv_api.ApivApi(client)
pod = api.list_pod()
self.assertEquals(3, len(pod.items))
endpoints = api.list_endpoints()
self.assertEquals(1, len(endpoints.items))
def setUp(self):
super(BaseK8sTest, self).setUp()
self.kube_api_url = self.cs.bays.get(self.bay.uuid).api_address
k8s_client = api_client.ApiClient(self.kube_api_url,
key_file=self.key_file,
cert_file=self.cert_file,
ca_certs=self.ca_file)
self.k8s_api = apiv_api.ApivApi(k8s_client)
# TODO(coreypobrien) https://bugs.launchpad.net/magnum/+bug/1551824
utils.wait_for_condition(self._is_api_ready, 5, 600)
def test_deployment_apis(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apisextensionsvbeta_api.ApisextensionsvbetaApi(client)
deployment_manifest = {
'kind': 'Deployment',
'spec': {
'template': {
'spec': {
'containers': [{
'image': 'nginx',
'name': 'test-deployment',
'ports': [{
'containerPort': 80
}]
}]
},
'metadata': {
'labels': {
'app': 'test-deployment'
}
}
},
'replicas': 2
},
'apiVersion': 'extensions/v1beta1',
'metadata': {
'name': 'test-deployment'
}
}
resp = api.create_namespaced_deployment(body=deployment_manifest,
namespace='default')
self.assertEqual('test-deployment', resp.metadata.name)
self.assertEqual(2, resp.spec.replicas)
resp = api.read_namespaced_deployment(name='test-deployment',
namespace='default')
self.assertEqual('test-deployment', resp.metadata.name)
self.assertEqual(2, resp.spec.replicas)
deployment_manifest['spec']['replicas'] = 1
resp = api.patch_namespaced_deployment(name='test-deployment',
namespace='default',
body=deployment_manifest)
self.assertEqual(1, resp.spec.replicas)
resp = api.delete_namespaced_deployment(name='test-deployment',
body={},
namespace='default')
def __init__(self, context, bay):
self.ca_file = None
self.cert_file = None
self.key_file = None
if bay.magnum_cert_ref:
self._create_certificate_files(bay)
# build a connection with Kubernetes master
client = api_client.ApiClient(bay.api_address,
key_file=self.key_file.name,
cert_file=self.cert_file.name,
ca_certs=self.ca_file.name)
super(K8sAPI, self).__init__(client)
def __init__(self, context, cluster):
self.ca_file = None
self.cert_file = None
self.key_file = None
if cluster.magnum_cert_ref:
(self.ca_file, self.key_file,
self.cert_file) = create_client_files(cluster, context)
# build a connection with Kubernetes master
client = api_client.ApiClient(cluster.api_address,
key_file=self.key_file.name,
cert_file=self.cert_file.name,
ca_certs=self.ca_file.name)
super(K8sAPI, self).__init__(client)
def test_list_endpoints(self):
client = api_client.ApiClient('http://127.0.0.1:8080/')
api = apiv_api.ApivApi(client)
endpoints = api.list_endpoints()
self.assertTrue(len(endpoints.items) > 0)
def __init__(self, endpoint):
super().__init__()
self.client = api_client.ApiClient(endpoint)
self.api = apiv_api.ApivApi(self.client)
self.helper = KubernetesHelper(self)
def __init__(self,
schema="https",
user=None,
password=None,
host='localhost',
port='443',
default_namespace='default'):
if user and password:
auth_string = '%s:%s' % (user, password)
auth = base64.encodestring(auth_string.encode()).decode()[:-1]
auth = "Basic {}".format(auth)
self._client = api_client.ApiClient(
'{schema}://{host}:{port}/'.format(schema=schema,
host=host,
port=port))
self._client.set_default_header('Authorization', auth)
restcli_impl = self._client.RESTClient.IMPL
restcli_impl.ssl_pool_manager.connection_pool_kw['cert_reqs'] = \
ssl.CERT_NONE
else:
self._client = api_client.ApiClient(
'{schema}://{host}:{port}/'.format(schema=schema,
host=host,
port=port))
self._api = apiv_api.ApivApi(self._client)
self._bapi = apisbatchv_api.ApisbatchvApi(self._client)
self._eapi = apisextensionsvbeta_api.ApisextensionsvbetaApi(
self._client)
self._default_namespace = default_namespace
self.nodes = K8sNodeManager(self._api, self._default_namespace)
self.pods = K8sPodManager(self._api, self._default_namespace)
self.endpoints = K8sEndpointManager(self._api, self._default_namespace)
self.namespaces = K8sNamespaceManager(self._api,
self._default_namespace)
self.services = K8sServiceManager(self._api, self._default_namespace)
self.serviceaccounts = K8sServiceAccountManager(
self._api, self._default_namespace)
self.secrets = K8sSecretManager(self._api, self._default_namespace)
self.events = K8sEventManager(self._api, self._default_namespace)
self.limitranges = K8sLimitRangeManager(self._api,
self._default_namespace)
self.jobs = K8sJobManager(self._bapi, self._default_namespace)
self.daemonsets = K8sDaemonSetManager(self._eapi,
self._default_namespace)
self.ingresses = K8sIngressManager(self._eapi, self._default_namespace)
self.deployments = K8sDeploymentManager(self._eapi,
self._default_namespace)
self.horizontalpodautoscalers = K8sHorizontalPodAutoscalerManager(
self._eapi, self._default_namespace)
self.componentstatuses = K8sComponentStatusManager(
self._api, self._default_namespace)
self.resourcequotas = K8sResourceQuotaManager(self._api,
self._default_namespace)
self.replicationcontrollers = K8sReplicationControllerManager(
self._api, self._default_namespace)
self.pvolumeclaims = K8sPersistentVolumeClaimManager(
self._api, self._default_namespace)
self.pvolumes = K8sPersistentVolumeManager(self._api,
self._default_namespace)
self.replicasets = K8sReplicaSetManager(self._eapi,
self._default_namespace)
