mirror of https://github.com/grpc/grpc.git
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
269 lines
10 KiB
269 lines
10 KiB
#!/usr/bin/env python2.7 |
|
# Copyright 2015, Google Inc. |
|
# All rights reserved. |
|
# |
|
# Redistribution and use in source and binary forms, with or without |
|
# modification, are permitted provided that the following conditions are |
|
# met: |
|
# |
|
# * Redistributions of source code must retain the above copyright |
|
# notice, this list of conditions and the following disclaimer. |
|
# * Redistributions in binary form must reproduce the above |
|
# copyright notice, this list of conditions and the following disclaimer |
|
# in the documentation and/or other materials provided with the |
|
# distribution. |
|
# * Neither the name of Google Inc. nor the names of its |
|
# contributors may be used to endorse or promote products derived from |
|
# this software without specific prior written permission. |
|
# |
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
|
|
import requests |
|
import json |
|
|
|
_REQUEST_TIMEOUT_SECS = 10 |
|
|
|
|
|
def _make_pod_config(pod_name, image_name, container_port_list, cmd_list, |
|
arg_list, env_dict): |
|
"""Creates a string containing the Pod defintion as required by the Kubernetes API""" |
|
body = { |
|
'kind': 'Pod', |
|
'apiVersion': 'v1', |
|
'metadata': { |
|
'name': pod_name, |
|
'labels': {'name': pod_name} |
|
}, |
|
'spec': { |
|
'containers': [ |
|
{ |
|
'name': pod_name, |
|
'image': image_name, |
|
'ports': [{'containerPort': port, |
|
'protocol': 'TCP'} |
|
for port in container_port_list], |
|
'imagePullPolicy': 'Always' |
|
} |
|
] |
|
} |
|
} |
|
|
|
env_list = [{'name': k, 'value': v} for (k, v) in env_dict.iteritems()] |
|
if len(env_list) > 0: |
|
body['spec']['containers'][0]['env'] = env_list |
|
|
|
# Add the 'Command' and 'Args' attributes if they are passed. |
|
# Note: |
|
# - 'Command' overrides the ENTRYPOINT in the Docker Image |
|
# - 'Args' override the CMD in Docker image (yes, it is confusing!) |
|
if len(cmd_list) > 0: |
|
body['spec']['containers'][0]['command'] = cmd_list |
|
if len(arg_list) > 0: |
|
body['spec']['containers'][0]['args'] = arg_list |
|
return json.dumps(body) |
|
|
|
|
|
def _make_service_config(service_name, pod_name, service_port_list, |
|
container_port_list, is_headless): |
|
"""Creates a string containing the Service definition as required by the Kubernetes API. |
|
|
|
NOTE: |
|
This creates either a Headless Service or 'LoadBalancer' service depending on |
|
the is_headless parameter. For Headless services, there is no 'type' attribute |
|
and the 'clusterIP' attribute is set to 'None'. Also, if the service is |
|
Headless, Kubernetes creates DNS entries for Pods - i.e creates DNS A-records |
|
mapping the service's name to the Pods' IPs |
|
""" |
|
if len(container_port_list) != len(service_port_list): |
|
print( |
|
'ERROR: container_port_list and service_port_list must be of same size') |
|
return '' |
|
body = { |
|
'kind': 'Service', |
|
'apiVersion': 'v1', |
|
'metadata': { |
|
'name': service_name, |
|
'labels': { |
|
'name': service_name |
|
} |
|
}, |
|
'spec': { |
|
'ports': [], |
|
'selector': { |
|
'name': pod_name |
|
} |
|
} |
|
} |
|
# Populate the 'ports' list in the 'spec' section. This maps service ports |
|
# (port numbers that are exposed by Kubernetes) to container ports (i.e port |
|
# numbers that are exposed by your Docker image) |
|
for idx in range(len(container_port_list)): |
|
port_entry = { |
|
'port': service_port_list[idx], |
|
'targetPort': container_port_list[idx], |
|
'protocol': 'TCP' |
|
} |
|
body['spec']['ports'].append(port_entry) |
|
|
|
# Make this either a LoadBalancer service or a headless service depending on |
|
# the is_headless parameter |
|
if is_headless: |
|
body['spec']['clusterIP'] = 'None' |
|
else: |
|
body['spec']['type'] = 'LoadBalancer' |
|
return json.dumps(body) |
|
|
|
|
|
def _print_connection_error(msg): |
|
print('ERROR: Connection failed. Did you remember to run Kubenetes proxy on ' |
|
'localhost (i.e kubectl proxy --port=<proxy_port>) ?. Error: %s' % msg) |
|
|
|
|
|
def _do_post(post_url, api_name, request_body): |
|
"""Helper to do HTTP POST. |
|
|
|
Note: |
|
1) On success, Kubernetes returns a success code of 201(CREATED) not 200(OK) |
|
2) A response code of 509(CONFLICT) is interpreted as a success code (since |
|
the error is most likely due to the resource already existing). This makes |
|
_do_post() idempotent which is semantically desirable. |
|
""" |
|
is_success = True |
|
try: |
|
r = requests.post(post_url, |
|
data=request_body, |
|
timeout=_REQUEST_TIMEOUT_SECS) |
|
if r.status_code == requests.codes.conflict: |
|
print('WARN: Looks like the resource already exists. Api: %s, url: %s' % |
|
(api_name, post_url)) |
|
elif r.status_code != requests.codes.created: |
|
print('ERROR: %s API returned error. HTTP response: (%d) %s' % |
|
(api_name, r.status_code, r.text)) |
|
is_success = False |
|
except (requests.exceptions.Timeout, |
|
requests.exceptions.ConnectionError) as e: |
|
is_success = False |
|
_print_connection_error(str(e)) |
|
return is_success |
|
|
|
|
|
def _do_delete(del_url, api_name): |
|
"""Helper to do HTTP DELETE. |
|
|
|
Note: A response code of 404(NOT_FOUND) is treated as success to keep |
|
_do_delete() idempotent. |
|
""" |
|
is_success = True |
|
try: |
|
r = requests.delete(del_url, timeout=_REQUEST_TIMEOUT_SECS) |
|
if r.status_code == requests.codes.not_found: |
|
print('WARN: The resource does not exist. Api: %s, url: %s' % |
|
(api_name, del_url)) |
|
elif r.status_code != requests.codes.ok: |
|
print('ERROR: %s API returned error. HTTP response: %s' % |
|
(api_name, r.text)) |
|
is_success = False |
|
except (requests.exceptions.Timeout, |
|
requests.exceptions.ConnectionError) as e: |
|
is_success = False |
|
_print_connection_error(str(e)) |
|
return is_success |
|
|
|
|
|
def create_service(kube_host, kube_port, namespace, service_name, pod_name, |
|
service_port_list, container_port_list, is_headless): |
|
"""Creates either a Headless Service or a LoadBalancer Service depending |
|
on the is_headless parameter. |
|
""" |
|
post_url = 'http://%s:%d/api/v1/namespaces/%s/services' % ( |
|
kube_host, kube_port, namespace) |
|
request_body = _make_service_config(service_name, pod_name, service_port_list, |
|
container_port_list, is_headless) |
|
return _do_post(post_url, 'Create Service', request_body) |
|
|
|
|
|
def create_pod(kube_host, kube_port, namespace, pod_name, image_name, |
|
container_port_list, cmd_list, arg_list, env_dict): |
|
"""Creates a Kubernetes Pod. |
|
|
|
Note that it is generally NOT considered a good practice to directly create |
|
Pods. Typically, the recommendation is to create 'Controllers' to create and |
|
manage Pods' lifecycle. Currently Kubernetes only supports 'Replication |
|
Controller' which creates a configurable number of 'identical Replicas' of |
|
Pods and automatically restarts any Pods in case of failures (for eg: Machine |
|
failures in Kubernetes). This makes it less flexible for our test use cases |
|
where we might want slightly different set of args to each Pod. Hence we |
|
directly create Pods and not care much about Kubernetes failures since those |
|
are very rare. |
|
""" |
|
post_url = 'http://%s:%d/api/v1/namespaces/%s/pods' % (kube_host, kube_port, |
|
namespace) |
|
request_body = _make_pod_config(pod_name, image_name, container_port_list, |
|
cmd_list, arg_list, env_dict) |
|
return _do_post(post_url, 'Create Pod', request_body) |
|
|
|
|
|
def delete_service(kube_host, kube_port, namespace, service_name): |
|
del_url = 'http://%s:%d/api/v1/namespaces/%s/services/%s' % ( |
|
kube_host, kube_port, namespace, service_name) |
|
return _do_delete(del_url, 'Delete Service') |
|
|
|
|
|
def delete_pod(kube_host, kube_port, namespace, pod_name): |
|
del_url = 'http://%s:%d/api/v1/namespaces/%s/pods/%s' % (kube_host, kube_port, |
|
namespace, pod_name) |
|
return _do_delete(del_url, 'Delete Pod') |
|
|
|
|
|
def create_pod_and_service(kube_host, kube_port, namespace, pod_name, |
|
image_name, container_port_list, cmd_list, arg_list, |
|
env_dict, is_headless_service): |
|
"""A helper function that creates a pod and a service (if pod creation was successful).""" |
|
is_success = create_pod(kube_host, kube_port, namespace, pod_name, image_name, |
|
container_port_list, cmd_list, arg_list, env_dict) |
|
if not is_success: |
|
print 'Error in creating Pod' |
|
return False |
|
|
|
is_success = create_service( |
|
kube_host, |
|
kube_port, |
|
namespace, |
|
pod_name, # Use pod_name for service |
|
pod_name, |
|
container_port_list, # Service port list same as container port list |
|
container_port_list, |
|
is_headless_service) |
|
if not is_success: |
|
print 'Error in creating Service' |
|
return False |
|
|
|
print 'Successfully created the pod/service %s' % pod_name |
|
return True |
|
|
|
|
|
def delete_pod_and_service(kube_host, kube_port, namespace, pod_name): |
|
""" A helper function that calls delete_pod and delete_service """ |
|
is_success = delete_pod(kube_host, kube_port, namespace, pod_name) |
|
if not is_success: |
|
print 'Error in deleting pod %s' % pod_name |
|
return False |
|
|
|
# Note: service name assumed to the the same as pod name |
|
is_success = delete_service(kube_host, kube_port, namespace, pod_name) |
|
if not is_success: |
|
print 'Error in deleting service %s' % pod_name |
|
return False |
|
|
|
print 'Successfully deleted the Pod/Service: %s' % pod_name |
|
return True
|
|
|