Switch to minikube/localkube

* Drop the old Kubernetes on docker containers method as it
  did not have a SSL enabled port
* Use localkube component from minikube instead. This enables
  us to drop the hitch TLS proxy as well.
* E2E tests should be easy to run locally and pick up configuration
  from ~/.kube/config
* Consolidate the urls in one spot (base.py), also consolidate the
  SkipTest in one spot.
* For local testing, just run minikube and run the py27 or py34 tox
  target, that should run all the tests including the e2e tests.
* Fix the connect_post_namespaced_pod_exec and add a e2e test for it

Fixes #122

Author: dims

.travis.yml

@@ -13,17 +13,8 @@ env:
   - TOXENV=docs
   - TOXENV=coverage,codecov
 
-# We use hitch (https://hitch-tls.org/) to setup TLS proxy from 8443 to 8080. while hitch is
-# in the ubuntu xenial main repos, it's not available by default on trusty. So we use the 
-# ppa from here : https://launchpad.net/~0k53d-karl-f830m/+archive/ubuntu/hitch
-before_install:
-  - sudo add-apt-repository ppa:0k53d-karl-f830m/hitch -y
-  - sudo apt-get -qq update
-  - sudo apt-get install hitch
-
 install:
   - pip install tox
-  - hitch --frontend=[*]:8443 --backend=[localhost]:8080 --daemon $TRAVIS_BUILD_DIR/scripts/example.pem
 
 script:
   - tox

kubernetes/client/api_client.py

@@ -346,7 +346,7 @@ def request(self, method, url, query_params=None, headers=None,
         """
         # FIXME(dims) : We need a better way to figure out which
         # calls end up using web sockets
-        if url.endswith('/exec') and method == "GET":
+        if url.endswith('/exec') and (method == "GET" or method == "POST"):
             return ws_client.GET(self.config,
                                  url,
                                  query_params=query_params,

kubernetes/e2e_test/base.py

@@ -12,21 +12,34 @@
 
 import copy
 import os
+import unittest
 import urllib3
 
 from kubernetes.client.configuration import configuration
+from kubernetes.config import kube_config
 
-def is_k8s_running():
-    try:
-        urllib3.PoolManager().request('GET', '127.0.0.1:8080')
-        return True
-    except urllib3.exceptions.HTTPError:
-        return False
+DEFAULT_E2E_HOST = '127.0.0.1'
 
 
-def setSSLConfiguration():
+def get_e2e_configuration():
     config = copy.copy(configuration)
-    config.verify_ssl = True
-    config.ssl_ca_cert = os.path.dirname(__file__) + '/../../scripts/example.pem'
-    config.assert_hostname = False
-    return config
+    config.host = None
+    if os.path.exists(
+            os.path.expanduser(kube_config.KUBE_CONFIG_DEFAULT_LOCATION)):
+        kube_config.load_kube_config(client_configuration=config)
+    else:
+        print('Unable to load config from %s' %
+              kube_config.KUBE_CONFIG_DEFAULT_LOCATION)
+        for url in ['https://%s:8443' % DEFAULT_E2E_HOST,
+                    'http://%s:8080' % DEFAULT_E2E_HOST]:
+            try:
+                urllib3.PoolManager().request('GET', url)
+                config.host = url
+                config.verify_ssl = False
+                break
+            except urllib3.exceptions.HTTPError:
+                pass
+    if config.host is None:
+        raise unittest.SkipTest('Unable to find a running Kubernetes instance')
+    print('Running test against : %s' % config.host)
+    return config

kubernetes/e2e_test/test_batch.py

@@ -17,21 +17,18 @@
 
 from kubernetes.client import api_client
 from kubernetes.client.apis import batch_v1_api
-from kubernetes.client.configuration import configuration
 from kubernetes.e2e_test import base
 
 
 class TestClientBatch(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.API_URL = 'http://127.0.0.1:8080/'
-        cls.config = configuration
+        cls.config = base.get_e2e_configuration()
+
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_job_apis(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = batch_v1_api.BatchV1Api(client)
 
         name = 'test-job-' + str(uuid.uuid4())
@@ -59,12 +56,4 @@ def test_job_apis(self):
         self.assertEqual(name, resp.metadata.name)
 
         resp = api.delete_namespaced_job(
-            name=name, body={}, namespace='default')
-
-
-class TestClientBatchSSL(TestClientBatch):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.API_URL = 'https://127.0.0.1:8443/'
-        cls.config = base.setSSLConfiguration()
+            name=name, body={}, namespace='default')

kubernetes/e2e_test/test_client.py

@@ -26,13 +26,10 @@ class TestClient(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.API_URL = 'http://127.0.0.1:8080/'
-        cls.config = configuration
+        cls.config = base.get_e2e_configuration()
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_pod_apis(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = core_v1_api.CoreV1Api(client)
 
         name = 'busybox-test-' + str(uuid.uuid4())
@@ -79,16 +76,22 @@ def test_pod_apis(self):
         print('EXEC response : %s' % resp)
         self.assertEqual(3, len(resp.splitlines()))
 
+        exec_command = 'uptime'
+        resp = api.connect_post_namespaced_pod_exec(name, 'default',
+                                                   command=exec_command,
+                                                   stderr=False, stdin=False,
+                                                   stdout=True, tty=False)
+        print('EXEC response : %s' % resp)
+        self.assertEqual(1, len(resp.splitlines()))
+
         number_of_pods = len(api.list_pod_for_all_namespaces().items)
         self.assertTrue(number_of_pods > 0)
 
         resp = api.delete_namespaced_pod(name=name, body={},
                                          namespace='default')
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_service_apis(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = core_v1_api.CoreV1Api(client)
 
         name = 'frontend-' + str(uuid.uuid4())
@@ -126,10 +129,8 @@ def test_service_apis(self):
         resp = api.delete_namespaced_service(name=name,
                                              namespace='default')
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_replication_controller_apis(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = core_v1_api.CoreV1Api(client)
 
         name = 'frontend-' + str(uuid.uuid4())
@@ -161,10 +162,8 @@ def test_replication_controller_apis(self):
         resp = api.delete_namespaced_replication_controller(
             name=name, body={}, namespace='default')
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_configmap_apis(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = core_v1_api.CoreV1Api(client)
 
         name = 'test-configmap-' + str(uuid.uuid4())
@@ -199,21 +198,11 @@ def test_configmap_apis(self):
         resp = api.list_namespaced_config_map('kube-system', pretty=True)
         self.assertEqual([], resp.items)
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_node_apis(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = core_v1_api.CoreV1Api(client)
 
         for item in api.list_node().items:
             node = api.read_node(name=item.metadata.name)
             self.assertTrue(len(node.metadata.labels) > 0)
-            self.assertTrue(isinstance(node.metadata.labels, dict))
-
-
-class TestClientSSL(TestClient):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.API_URL = 'https://127.0.0.1:8443/'
-        cls.config = base.setSSLConfiguration()
+            self.assertTrue(isinstance(node.metadata.labels, dict))

kubernetes/e2e_test/test_extensions.py

@@ -27,13 +27,10 @@ class TestClientExtensions(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.API_URL = 'http://127.0.0.1:8080/'
-        cls.config = configuration
+        cls.config = base.get_e2e_configuration()
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_create_deployment(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = extensions_v1beta1_api.ExtensionsV1beta1Api(client)
         name = 'nginx-deployment-' + str(uuid.uuid4())
         deployment = '''apiVersion: extensions/v1beta1
@@ -62,10 +59,8 @@ def test_create_deployment(self):
         options = v1_delete_options.V1DeleteOptions()
         resp = api.delete_namespaced_deployment(name, 'default', body=options)
 
-    @unittest.skipUnless(
-        base.is_k8s_running(), "Kubernetes is not available")
     def test_create_daemonset(self):
-        client = api_client.ApiClient(self.API_URL, config=self.config)
+        client = api_client.ApiClient(config=self.config)
         api = extensions_v1beta1_api.ExtensionsV1beta1Api(client)
         name = 'nginx-app-' + str(uuid.uuid4())
         daemonset = {
@@ -97,12 +92,4 @@ def test_create_daemonset(self):
         self.assertIsNotNone(resp)
 
         options = v1_delete_options.V1DeleteOptions()
-        resp = api.delete_namespaced_daemon_set(name, 'default', body=options)
-
-
-class TestClientExtensionsSSL(TestClientExtensions):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.API_URL = 'https://127.0.0.1:8443/'
-        cls.config = base.setSSLConfiguration()
+        resp = api.delete_namespaced_daemon_set(name, 'default', body=options)