From f86047e7cbf88db3e5a106468bedea7878357bcd Mon Sep 17 00:00:00 2001 From: Eric Lund Date: Thu, 4 Apr 2024 17:45:36 -0500 Subject: [PATCH] Add API objects for Blade Interconnects and Virtual Blades --- vtds_provider_gcp/api_objects.py | 138 +++++ vtds_provider_gcp/private/api_objects.py | 490 ++++++++++++++++++ .../private/blade_interconnect.py | 2 +- vtds_provider_gcp/private/private_provider.py | 19 + vtds_provider_gcp/private/terragrunt.py | 6 +- vtds_provider_gcp/private/virtual_blade.py | 2 +- vtds_provider_gcp/provider.py | 14 + 7 files changed, 666 insertions(+), 5 deletions(-) create mode 100644 vtds_provider_gcp/api_objects.py create mode 100644 vtds_provider_gcp/private/api_objects.py diff --git a/vtds_provider_gcp/api_objects.py b/vtds_provider_gcp/api_objects.py new file mode 100644 index 0000000..f04c507 --- /dev/null +++ b/vtds_provider_gcp/api_objects.py @@ -0,0 +1,138 @@ +# +# MIT License +# +# (C) Copyright [2024] Hewlett Packard Enterprise Development LP +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. +"""Objects presented on the Layer API containing public information +and operations in the provider layer. + +""" +from contextlib import contextmanager +from abc import ( + ABCMeta, + abstractmethod +) + + +class VirtualBlades(metaclass=ABCMeta): + """A class implementing public access to Virtual Blades and their + operations. + + """ + @abstractmethod + def blade_count(self, blade_type): + """Get the number of Virtual Blade instances of the specified + type. + + """ + + @abstractmethod + def blade_interconnects(self, blade_type): + """Return the list of Blade Interconnects by name connected to + the specified type of Virtual Blade. + + """ + + @abstractmethod + def blade_hostname(self, blade_type, instance): + """Get the hostname of a given instance of the specified type + of Virtual Blade. + + """ + + @abstractmethod + def blade_ip(self, blade_type, instance, interconnect): + """Return the IP address (string) on the named Blade + Interconnect of a specified instance of the named Virtual + Blade type. + + """ + + @abstractmethod + @contextmanager + def connect_blade(self, remote_port, blade_type, instance): + """Establish an external connection to the specified remote + port on the specified instance of the named Virtual Blade + type. Return a context manager (suitable for use in a 'with' + clause) yielding an APIBladeConnection object for the + connection. Upon leaving the 'with' context, the connection in + the APIBladeConnection is closed. + + """ + + @contextmanager + @abstractmethod + def connect_blades(self, remote_port, blade_types=None): + """Establish external connections to the specified remote port + on all the Virtual Blade instances on all the Virtual Blade + types listed by name in 'blade_types'. If 'blade_types' is not + provided or None, all available blade types are used. Return a + context manager (suitable for use in a 'with' clause) yielding + the list of APIBladeConnection objects representing the + connections. Upon leaving the 'with' context, all the + connections in the resulting list are closed. + + """ + + +class BladeInterconnects(metaclass=ABCMeta): + """The external representation of the set of Blade Interconnects + and public operations that can be performed on the interconnects. + + """ + @abstractmethod + def ipv4_cidr(self, interconnect_name): + """Return the (string) IPv4 CIDR (/) for the + network on the named interconnect. + + """ + + +class BladeConnection(metaclass=ABCMeta): + """A class containing the relevant information needed to use + external connections to ports on a specific Virtual Blade. + + """ + @abstractmethod + def blade_type(self): + """Return the name of the Virtual Blade type of the connected + Virtual Blade. + + """ + + @abstractmethod + def blade_hostname(self): + """Return the hostname of the connected Virtual Blade. + + """ + + @abstractmethod + def local_ip(self): + """Return the locally reachable IP address of the connection + to the Virtual Blade. + + """ + + @abstractmethod + def local_port(self): + """Return the TCP port number on the locally reachable IP + address of the connection to the Virtual Blade. + + """ diff --git a/vtds_provider_gcp/private/api_objects.py b/vtds_provider_gcp/private/api_objects.py new file mode 100644 index 0000000..59ffb30 --- /dev/null +++ b/vtds_provider_gcp/private/api_objects.py @@ -0,0 +1,490 @@ +# +# MIT License +# +# (C) Copyright [2024] Hewlett Packard Enterprise Development LP +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. +"""Private implementations of API objects. + +""" +from os.path import join as path_join +from os import makedirs +from contextlib import contextmanager +from subprocess import ( + Popen, + PIPE +) +from socketserver import TCPServer +from socket import ( + socket, + AF_INET, + SOCK_STREAM +) +from time import sleep + +from vtds_base import ( + ContextualError, + logfile +) +from ..api_objects import ( + VirtualBlades, + BladeInterconnects, + BladeConnection +) + + +# pylint: disable=invalid-name +class PrivateVirtualBlades(VirtualBlades): + """The external representation of a class of Virtual Blades and + the public operations that can be performed on blades in that + class. Virtual Blade operations refer to individual blades by + their instance number which is an integer greater than or equal to + 0 and less that the number of blade instances in the class. + + """ + def __init__(self, config, build_dir): + """Constructor + + """ + self.config = config + self.build_dir = build_dir + self.project_id = None + + def __get_blade(self, blade_type): + """class private: retrieve the blade type deascription for the + named type. + + """ + virtual_blades = ( + self.config.get('virtual_blades', {}) + ) + blade = virtual_blades.get(blade_type, None) + if blade is None: + raise ContextualError( + "cannot find the virtual blade type '%s'" % blade_type + ) + if blade.get('pure_base_class', False): + raise ContextualError( + "blade type '%s' is a pure pure base class" % blade_type + ) + return blade + + def __check_instance(self, blade_type, instance): + """class private: Ensure that the specified instance number + for a given blade type (blades) is legal. + + """ + if not isinstance(instance, int): + raise ContextualError( + "Virtual Blade instance number must be integer not '%s'" % + type(instance) + ) + blade = self.__get_blade(blade_type) + count = int(blade.get('count', 0)) + if instance < 0 or instance >= count: + raise ContextualError( + "instance number %d out of range for Virtual Blade " + "type '%s' which has a count of %d" % + (instance, blade_type, count) + ) + + def __get_interconnect(self, blade_type, interconnect): + """class private: Get the named interconnect information from + the specified Virtual Blade type. + + """ + blade = self.__get_blade(blade_type) + blade_interconnect = blade.get('blade_interconnect', None) + if blade_interconnect is None: + raise ContextualError( + "provider config error: Virtual Blade type '%s' has no " + "blade interconnect configured" % blade_type + ) + if blade_interconnect.get("subnetwork", None) != interconnect: + raise ContextualError( + "Virtual Blade type '%s' is not configured to use " + "blade interconnect '%s'" % (blade_type, interconnect) + ) + return blade_interconnect + + def _get_project_id(self): + """layer private: Retrieve the project ID for the current vTDS + project. + + """ + if self.project_id is not None: + return self.project_id + organization_name = ( + self.config.get('organization', {}).get('name', None) + ) + if organization_name is None: + raise ContextualError( + "provider config error: cannot find 'name' in " + "'provider.organization'" + ) + base_name = ( + self.config.get('project', {}).get('base_name', None) + ) + if base_name is None: + raise ContextualError( + "provider config error: cannot find 'base_name' in " + "'provider.project'" + ) + project_name = "%s-%s" % (organization_name, base_name) + with Popen( + [ + 'gcloud', 'projects', 'list', + '--filter=name=%s' % project_name, + '--format=value(PROJECT_ID)' + ], + stdout=PIPE, + stderr=PIPE, + text=True, encoding='UTF-8' + ) as cmd: + self.project_id = cmd.stdout.readline()[:-1] + return self.project_id + + def _get_zone(self): + """Layer private: get the configured zone in which resources + for this project reside. + + """ + zone = self.config.get('project', {}).get('zone', None) + if zone is None: + raise ContextualError( + "provider config error: cannot find 'zone' in " + "'provider.project'" + ) + return zone + + def _get_build_dir(self): + """Layer private: get the build directory for this run of the + vTDS tool. + + """ + return self.build_dir + + def _log_paths(self, logname): + """Layer private: an 'out' path and an 'error' path based on + the base name 'logname' and return both to the caller. + + """ + directory = path_join(self.build_dir, "virtual_blades") + logs = path_join(directory, "logs") + try: + makedirs(logs, mode=0o755, exist_ok=True) + except OSError as err: + raise ContextualError( + "failed to create log directory '%s' - %s" % ( + logs, str(err) + ) + ) from err + out_path = path_join( + logs, + "%s-out.txt" % (logname) + ) + err_path = path_join( + logs, + "%s-err.txt" % (logname) + ) + return out_path, err_path + + def blade_count(self, blade_type): + """Get the number of Virtual Blade instances of the specified + type. + + """ + blade = self.__get_blade(blade_type) + return int(blade.get('count', 0)) + + def blade_interconnects(self, blade_type): + """Return the list of Blade Interconnects by name connected to + the specified type of Virtual Blade. + + """ + blade = self.__get_blade(blade_type) + # The GCP provider only lets us have one interconnect per + # blade type, so we are just going to go grab that and make it + # into a 'list' of one item. + name = blade.get('blade_interconnect', {}).get('subnetwork', None) + if name is None: + raise ContextualError( + "provider config error: no 'blade_interconnect.subnetwork' " + "found in blade type '%s'" % blade_type + ) + return [name] + + def blade_hostname(self, blade_type, instance): + """Get the hostname of a given instance of the specified type + of Virtual Blade. + + """ + self.__check_instance(blade_type, instance) + blade = self.__get_blade(blade_type) + if 'hostname' not in blade: + raise ContextualError( + "provider config error: no 'hostname' configured for " + "Virtual Blade type '%s'" % blade_type + ) + count = self.blade_count(blade_type) + add_suffix = blade.get('add_hostname_suffix', count > 1) + hostname = blade['hostname'] + separator = ( + blade.get('hostname_suffix_separator', "") if add_suffix else "" + ) + # Suffixes are 1 based, not 0 based, instances are 0 based + suffix = "%3.3d" % (instance + 1) if add_suffix else "" + return hostname + separator + suffix + + def blade_ip(self, blade_type, instance, interconnect): + """Return the IP address (string) on the named Blade + Interconnect of a specified instance of the named Virtual + Blade type. + + """ + self.__check_instance(blade_type, instance) + blade_interconnect = self.__get_interconnect(blade_type, interconnect) + ip_addrs = blade_interconnect.get('ip_addrs', None) + if not ip_addrs: + raise ContextualError( + "provider config error: Virtual Blade type '%s' has no " + "'ip_addrs' configured" + ) + if instance >= len(ip_addrs): + raise ContextualError( + "provider config error: Virtual Blade type is configured with " + "fewer ip_addrs (%d) than blade instances (%d)" % + (len(ip_addrs), self.blade_count(blade_type)) + ) + return ip_addrs[instance] + + @contextmanager + def connect_blade(self, remote_port, blade_type, instance): + """Establish an external connection to the specified remote + port on the specified instance of the named Virtual Blade + type. Return a context manager (suitable for use in a 'with' + clause) yielding a BladeConnection object for the + connection. Upon leaving the 'with' context, the connection in + the BladeConnection is closed. + + """ + connection = PrivateBladeConnection( + self, blade_type, instance, remote_port + ) + try: + yield connection + finally: + # This is a layer private operation not really class + # private. Treat this reference as friendly. + connection._disconnect() # pylint: disable=protected-access + + @contextmanager + def connect_blades(self, remote_port, blade_types=None): + """Establish external connections to the specified remote port + on all the Virtual Blade instances on all the Virtual Blade + types listed by name in 'blade_types'. If 'blade_types' is not + provided or None, all available blade types are used. Return a + context manager (suitable for use in a 'with' clause) yielding + the list of APIBladeConnection objects representing the + connections. Upon leaving the 'with' context, all the + connections in the resulting list are closed. + + """ + virtual_blades = ( + self.config.get('virtual_blades', {}) + ) + blade_types = ( + blade_types if blade_types is not None else + [ + name for name in virtual_blades + if not virtual_blades[name].get('pure_base_class', False) + ] + ) + connections = [ + PrivateBladeConnection(self, blade_type, instance, remote_port) + for blade_type in blade_types + for instance in range(0, self.blade_count(blade_type)) + ] + try: + yield connections + finally: + for connection in connections: + # This is a layer private operation not really class + # private. Treat this reference as friendly. + connection._disconnect() # pylint: disable=protected-access + + +class PrivateBladeInterconnects(BladeInterconnects): + """The external representation of the set of Blade Interconnects + and public operations that can be performed on the interconnects. + + """ + def __init__(self, config, build_dir): + """Constructor + + """ + self.config = config + self.build_dir = build_dir + + def ipv4_cidr(self, interconnect_name): + """Return the (string) IPv4 CIDR (/) for the + network on the named interconnect. + + """ + blade_interconnects = ( + self.config.get("provider", {}).get("blade_interconnects", {}) + ) + if interconnect_name not in blade_interconnects: + raise ContextualError( + "requestiong ipv4_cidr of unknown blade interconnect '%s'" % + interconnect_name + ) + interconnect = blade_interconnects.get(interconnect_name, {}) + if 'ipv4_cidr' not in interconnect: + raise ContextualError( + "provider layer configuration error: no 'ipv4_cidr' found in " + "blade interconnect named '%s'" % interconnect_name + ) + return interconnect['ipv4_cidr'] + + +# pylint: disable=invalid-name +class PrivateBladeConnection(BladeConnection): + """A class containing the relevant information needed to use + external connections to ports on a specific Virtual Blade. + + """ + def __init__(self, virtual_blades, blade_type, instance, remote_port): + """Constructor + + """ + self.virtual_blades = virtual_blades + self.blade_type = blade_type + self.instance = instance + self.remote_port = remote_port + self.hostname = self.virtual_blades.blade_hostname( + blade_type, instance + ) + self.local_ip = "127.0.0.1" + self.loc_port = None + self.subprocess = None + self._connect() + + def _connect(self): + """Layer private operation: establish the connection and learn + the local IP and port of the connection. + + """ + # Get a "free" port to use for the connection by briefly + # binding a TCP server and then destroying it before it + # listens on anything. + with TCPServer((self.local_ip, 0), None) as tmp: + self.loc_port = tmp.server_address[1] + + # pylint: disable=protected-access + zone = self.virtual_blades._get_zone() + + # pylint: disable=protected-access + project_id = self.virtual_blades._get_project_id() + + logname = "connection-%s-port-%d" % (self.hostname, self.remote_port) + # pylint: disable=protected-access + out_path, err_path = self.virtual_blades._log_paths(logname) + with logfile(out_path) as out, logfile(err_path) as err: + # Not using 'with' for the Popen because the Popen object + # becomes part of this class instance for the duration of + # the class instance's life cycle. The instance itself is + # handed out through a context manager which will + # disconnect and destroy the Popen object when the context + # ends. + # + # pylint: disable=consider-using-with + self.subprocess = Popen( + [ + 'gcloud', 'compute', '--project=%s' % project_id, + 'start-iap-tunnel', + '--zone=%s' % zone, + self.hostname, + str(self.remote_port), + '--local-host-port=%s:%s' % (self.local_ip, self.loc_port) + ], + stdout=out, stderr=err, + text=True, encoding='UTF-8' + ) + + # Wait for the tunnel to be established before returning. + retries = 60 + while retries > 0: + with socket(AF_INET, SOCK_STREAM) as tmp: + try: + tmp.connect((self.local_ip, self.loc_port)) + return + except ConnectionRefusedError: + sleep(1) + retries -= 1 + except Exception as err: + self._disconnect() + raise ContextualError( + "internal error: failed attempt to connect to " + "service on IAP tunnel to '%s' port %d - %s" % ( + self.hostname, self.remote_port, str(err) + ), + out_path, err_path + ) from err + # If we got out of the loop we timed out trying to connect... + self._disconnect() + raise ContextualError( + "internal error: timeout waiting for IAP connection to '%s' " + "port %d to be ready" % (self.hostname, self.remote_port), + out_path, err_path + ) + + def _disconnect(self): + """Layer private operation: drop the connection. + """ + self.subprocess.kill() + self.subprocess = None + self.loc_port = None + + def blade_type(self): + """Return the name of the Virtual Blade type of the connected + Virtual Blade. + + """ + return self.blade_type + + def blade_hostname(self): + """Return the hostname of the connected Virtual Blade. + + """ + return self.hostname + + def local_ip(self): + """Return the locally reachable IP address of the connection + to the Virtual Blade. + + """ + return self.local_ip + + def local_port(self): + """Return the TCP port number on the locally reachable IP + address of the connection to the Virtual Blade. + + """ + return self.loc_port diff --git a/vtds_provider_gcp/private/blade_interconnect.py b/vtds_provider_gcp/private/blade_interconnect.py index ca25a93..b9639c8 100644 --- a/vtds_provider_gcp/private/blade_interconnect.py +++ b/vtds_provider_gcp/private/blade_interconnect.py @@ -73,7 +73,7 @@ def _make_old_style_rule(rule, direction): 'deny': rule.get('deny', []), 'log_config': rule.get('log_config', {}), } - + @classmethod def _convert_firewalls(cls, interconnect_config): """Convert ingress and egress firewall rules in a diff --git a/vtds_provider_gcp/private/private_provider.py b/vtds_provider_gcp/private/private_provider.py index cbfc26f..c05affe 100644 --- a/vtds_provider_gcp/private/private_provider.py +++ b/vtds_provider_gcp/private/private_provider.py @@ -36,6 +36,10 @@ ) from .virtual_blade import VirtualBlade from .blade_interconnect import BladeInterconnect +from .api_objects import ( + PrivateVirtualBlades, + PrivateBladeInterconnects +) class PrivateProvider: @@ -50,6 +54,7 @@ def __init__(self, stack, config, build_dir): """ self.config = config + self.build_dir = build_dir self.terragrunt = Terragrunt(build_dir) self.terragrunt_config = TerragruntConfig(self.terragrunt) self.stack = stack @@ -185,3 +190,17 @@ def remove(self): "cannot deploy an unprepared provider, call prepare() first" ) self.terragrunt.remove() + + def get_virtual_blades(self): + """Return a the VirtualBlades object containing all of the + available non-pure-base-class Virtual Blades. + + """ + return PrivateVirtualBlades(self.config, self.build_dir) + + def get_blade_interconnects(self): + """Return a BladeInterconnects object containing all the + available non-pure-base-class Blade Interconnects. + + """ + return PrivateBladeInterconnects(self.config, self.build_dir) diff --git a/vtds_provider_gcp/private/terragrunt.py b/vtds_provider_gcp/private/terragrunt.py index 7536855..9d3abbd 100644 --- a/vtds_provider_gcp/private/terragrunt.py +++ b/vtds_provider_gcp/private/terragrunt.py @@ -76,7 +76,7 @@ def __run__(self, subdir, operation, tag, timeout=None): """ directory = path_join(self.build_dir, subdir) - logs = path_join(self.build_dir, "logs") + logs = path_join(directory, "logs") err_path = path_join( logs, "terragrunt_%s[%s]-err.txt" % (operation, tag)) @@ -209,7 +209,7 @@ def template_path(self, sub_path): """ return path_join( - TERRAGRUNT_DIR,"templates", sub_path + TERRAGRUNT_DIR, "templates", sub_path ) def build_path(self, sub_path): @@ -288,7 +288,7 @@ def initialize(self, config): # Write out the vtds.yaml that results from the fully resolved # configuration. config_path = self.terragrunt_env.build_path( - path_join("terragrunt","vtds.yaml") + path_join("terragrunt", "vtds.yaml") ) try: with open(config_path, 'w', encoding="UTF-8") as config_file: diff --git a/vtds_provider_gcp/private/virtual_blade.py b/vtds_provider_gcp/private/virtual_blade.py index 08bc755..160fce1 100644 --- a/vtds_provider_gcp/private/virtual_blade.py +++ b/vtds_provider_gcp/private/virtual_blade.py @@ -37,7 +37,7 @@ class VirtualBlade: """Class representing a single virtual blade type as defined in the vTDS configuration and implemented in the vTDS Terragrunt - configuration / constrol struture. + configuration / control struture. """ def __init__(self, terragrunt): diff --git a/vtds_provider_gcp/provider.py b/vtds_provider_gcp/provider.py index 76ab435..afb81c7 100644 --- a/vtds_provider_gcp/provider.py +++ b/vtds_provider_gcp/provider.py @@ -111,3 +111,17 @@ def remove(self): """ self.private.remove() + + def get_virtual_blades(self): + """Return a the VirtualBlades object containing all of the + available non-pure-base-class Virtual Blades. + + """ + return self.private.get_virtual_blades() + + def get_blade_interconnects(self): + """Return a BladeInterconnects object containing all the + available non-pure-base-class Blade Interconnects. + + """ + return self.private.get_blade_interconnects()