diff options
Diffstat (limited to 'snaps/config/cluster_template.py')
| -rw-r--r-- | snaps/config/cluster_template.py | 306 |
1 files changed, 306 insertions, 0 deletions
diff --git a/snaps/config/cluster_template.py b/snaps/config/cluster_template.py new file mode 100644 index 0000000..a20225a --- /dev/null +++ b/snaps/config/cluster_template.py @@ -0,0 +1,306 @@ +# Copyright (c) 2016 Cable Television Laboratories, Inc. ("CableLabs") +# and others. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import enum +from neutronclient.common.utils import str2bool + + +class ServerType(enum.Enum): + """ + The cluter server types supported + """ + vm = 'vm' + baremetal = 'baremetal' + + +class ContainerOrchestrationEngine(enum.Enum): + """ + The types of supported COEs + """ + kubernetes = 'kubernetes' + swarm = 'swarm' + mesos = 'mesos' + + +class DockerStorageDriver(enum.Enum): + """ + Drivers for managing storage for the images in the container's writable + layer + """ + devicemapper = 'devicemapper' + overlay = 'overlay' + + +class ClusterTemplateConfig(object): + """ + Configuration settings for OpenStack cluster template creation + """ + + def __init__(self, **kwargs): + """ + Constructor + :param name: the cluster type's name (required) + :param image: name or ID of the base image in Glance used to boot the + cluster's servers. The image must have the attribute + 'os-distro' defined as appropriate for the cluster + driver (required) + :param keypair: name or ID of the keypair to gain cluster machine + access (required) + :param network_driver: The name of a network driver for providing the + networks for the containers. Note that this is + different and separate from the Neutron network + for the bay/cluster. The operation and + networking model are specific to the particular + driver (optional) + :param external_net: name or IDof the external Neutron network to + provide connectivity to the cluster (required) + :param floating_ip_enabled: Whether enable or not using the floating IP + of cloud provider. Some cloud providers + used floating IP, some used public IP, + thus Magnum provide this option for + specifying the choice of using floating IP + (default - True) + :param docker_volume_size: The size in GB for the local storage on each + server for the Docker daemon to cache the + images and host the containers. Cinder + volumes provide the storage. The default is + 25 GB. For the devicemapper storage driver, + the minimum value is 3GB. For the overlay + storage driver, the minimum value is 1GB. + (default - 3) + :param server_type: ServerType enumeration (default - vm) + :param flavor: name or ID of the nova flavor for booting the node + servers (default - m1.small) + :param master_flavor: name or ID of the nova flavor of the master node + for this cluster (optional) + :param coe: ContainerOrchestrationEngine enum instance + (default - kubernetes) + :param fixed_net: name of a Neutron network to provide connectivity + to the internal network for the cluster + (optional) + :param fixed_subnet: Fixed subnet that are using to allocate network + address for nodes in bay/cluster (optional) + :param registry_enabled: Docker images by default are pulled from the + public Docker registry, but in some cases, + users may want to use a private registry. + This option provides an alternative registry + based on the Registry V2: Magnum will create a + local registry in the bay/cluster backed by + swift to host the images (default - True) + :param insecure_registry: The URL pointing to the user's own private + insecure docker registry to deploy and run + docker containers (optional) + :param docker_storage_driver: DockerStorageDriver enum instance to + manage storage for the images and + container's writable layer + (default - devicemapper) + :param dns_nameserver: The DNS nameserver for the servers and + containers in the bay/cluster to use. + This is configured in the private Neutron + network for the bay/cluster. + (default provided by Magnum - 8.8.8.8) + :param public: denotes whether or not the cluster type is public + (default False) + :param tls_disabled: denotes whether or not TLS should be enabled + (default False) + :param http_proxy: host:port for a proxy to use when direct HTTP + access from the servers to sites on the external + internet is blocked (optional) + :param https_proxy: host:port for a proxy to use when direct HTTPS + access from the servers to sites on the external + internet is blocked (optional) + :param no_proxy: comma separated list of IPs that should not be + redirected through the proxy (optional) + :param volume_driver: The name of a volume driver for managing the + persistent storage for the containers. The + functionality supported are specific to the + driver (optional) + :param master_lb_enabled: Since multiple masters may exist in a + bay/cluster, a Neutron load balancer is + created to provide the API endpoint for the + bay/cluster and to direct requests to the + masters. In some cases, such as when the + LBaaS service is not available, this option + can be set to false to create a bay/cluster + without the load balancer. In this case, one + of the masters will serve as the API endpoint + (default - True) + :param labels: Arbitrary labels in the form of a dict. The accepted + keys and valid values are defined in the bay/cluster + drivers. They are used as a way to pass additional + parameters that are specific to a bay/cluster driver. + (optional) + """ + self.name = kwargs.get('name') + self.image = kwargs.get('image') + self.keypair = kwargs.get('keypair') + self.network_driver = kwargs.get('network_driver') + self.external_net = kwargs.get('external_net') + self.floating_ip_enabled = str2bool( + str(kwargs.get('floating_ip_enabled', True))) + self.docker_volume_size = int(kwargs.get('docker_volume_size', 3)) + self.server_type = map_server_type( + kwargs.get('server_type', ServerType.vm)) + self.flavor = kwargs.get('flavor') + self.master_flavor = kwargs.get('master_flavor') + self.coe = map_coe( + kwargs.get('coe', ContainerOrchestrationEngine.kubernetes)) + self.fixed_net = kwargs.get('fixed_net') + self.fixed_subnet = kwargs.get('fixed_subnet') + self.registry_enabled = str2bool( + str(kwargs.get('registry_enabled', True))) + self.insecure_registry = kwargs.get('insecure_registry') + self.docker_storage_driver = map_docker_storage_driver( + kwargs.get('docker_storage_driver', + DockerStorageDriver.devicemapper)) + self.dns_nameserver = kwargs.get('dns_nameserver') + self.public = str2bool(str(kwargs.get('public', False))) + self.tls_disabled = str2bool(str(kwargs.get('tls_disabled', False))) + self.http_proxy = kwargs.get('http_proxy') + self.https_proxy = kwargs.get('https_proxy') + self.no_proxy = kwargs.get('no_proxy') + self.volume_driver = kwargs.get('volume_driver') + self.master_lb_enabled = str2bool( + str(kwargs.get('master_lb_enabled', True))) + self.labels = kwargs.get('labels') + + if (not self.name or not self.image or not self.keypair + or not self.external_net): + raise ClusterTypeConfigError( + 'The attributes name, image, keypair, and ' + 'external_net are required for ClusterTypeConfig') + + def magnum_dict(self): + """ + Returns a dictionary object representing this object. + This is meant to be sent into as kwargs into the Magnum client + + :return: the dictionary object + """ + out = dict() + + if self.name: + out['name'] = self.name + if self.image: + out['image_id'] = self.image + if self.keypair: + out['keypair_id'] = self.keypair + if self.network_driver: + out['network_driver'] = self.network_driver + if self.external_net: + out['external_network_id'] = self.external_net + if self.floating_ip_enabled: + out['floating_ip_enabled'] = self.floating_ip_enabled + if self.docker_volume_size: + out['docker_volume_size'] = self.docker_volume_size + if self.server_type: + out['server_type'] = self.server_type.value + if self.flavor: + out['flavor_id'] = self.flavor + if self.master_flavor: + out['master_flavor_id'] = self.master_flavor + if self.coe: + out['coe'] = self.coe.value + if self.fixed_net: + out['fixed_network'] = self.fixed_net + if self.fixed_subnet: + out['fixed_subnet'] = self.fixed_subnet + if self.registry_enabled: + out['registry_enabled'] = self.registry_enabled + if self.insecure_registry: + out['insecure_registry'] = self.insecure_registry + if self.docker_storage_driver: + out['docker_storage_driver'] = self.docker_storage_driver.value + if self.dns_nameserver: + out['dns_nameserver'] = self.dns_nameserver + if self.public: + out['public'] = self.public + if self.tls_disabled: + out['tls_disabled'] = self.tls_disabled + if self.http_proxy: + out['http_proxy'] = self.http_proxy + if self.https_proxy: + out['https_proxy'] = self.https_proxy + if self.no_proxy: + out['no_proxy'] = self.no_proxy + if self.volume_driver: + out['volume_driver'] = self.volume_driver + if self.master_lb_enabled: + out['master_lb_enabled'] = self.master_lb_enabled + if self.labels: + out['labels'] = self.labels + return out + + +class ClusterTypeConfigError(Exception): + """ + Exception to be thrown when a cluster type configuration is incorrect + """ + + +def map_server_type(server_type): + """ + Takes a the server_type value maps it to the ServerType enum. When None + return None + :param server_type: the server_type value to map + :return: the ServerType enum object + :raise: ClusterTypeConfigError if value is invalid + """ + if not server_type: + return None + if isinstance(server_type, ServerType): + return server_type + elif isinstance(server_type, str): + for this_type in ServerType: + if this_type.value == server_type: + return this_type + raise ClusterTypeConfigError('Invalid server type - ' + server_type) + + +def map_coe(coe): + """ + Takes a the coe value maps it to the ContainerOrchestrationEngine enum. + When None return None + :param coe: the COE value to map + :return: the ContainerOrchestrationEngine enum object + :raise: ClusterTypeConfigError if value is invalid + """ + if not coe: + return None + if isinstance(coe, ContainerOrchestrationEngine): + return coe + elif isinstance(coe, str): + for this_type in ContainerOrchestrationEngine: + if this_type.value == coe: + return this_type + raise ClusterTypeConfigError('Invalid COE - ' + coe) + + +def map_docker_storage_driver(driver): + """ + Takes a the coe value maps it to the ContainerOrchestrationEngine enum. + When None return None + :param driver: the docker storage driver value to map + :return: the DockerStorageDriver enum object + :raise: ClusterTypeConfigError if value is invalid + """ + if not driver: + return None + if isinstance(driver, DockerStorageDriver): + return driver + elif isinstance(driver, str): + for this_type in DockerStorageDriver: + if this_type.value == driver: + return this_type + raise ClusterTypeConfigError('Invalid DockerStorageDriver - ' + driver) |