libraries/cluster/testutils/host.py

   1 # Copyright 2019 Nokia
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import abc
  16 import six
  17 from . profiles import (
  18     MasterProfile,
  19     WorkerProfile,
  20     StorageProfile,
  21     BaseProfile,
  22     ManagementProfile)
  23
  24
  25 class Host(object):
  26     def __init__(self, name, service_profiles, ippool):
  27         self.name = name
  28         self.service_profiles = service_profiles
  29         self.internal_ip = ippool.get_internal_ip()
  30         self.external_ip = ippool.get_external_ip()
  31
  32     @property
  33     def host_dict(self):
  34         d = self._service_profiles_dict
  35         d.update({'network_domain': self.expected_network_domain})
  36         d.update(self._network_profiles_dict)
  37         return d
  38
  39     @property
  40     def _service_profiles_dict(self):
  41         return {'service_profiles': [str(s()) for s in self.service_profiles]}
  42
  43     @property
  44     def expected_network_domain(self):
  45         return '{name}-domain-name'.format(name=self.name)
  46
  47     @property
  48     def _network_profiles_dict(self):
  49         return {'network_profiles': self._network_profiles}
  50
  51     @property
  52     def _network_profiles(self):
  53         return ['network_nondpdk']
  54
  55     @property
  56     def networking(self):
  57         return {'infra_internal': {'ip': self.internal_ip},
  58                 'infra_external': {'ip': self.external_ip}}
  59
  60     @property
  61     def network_profile_details(self):
  62         return {
  63             'network_nondpdk': {
  64                 'provider_network_interfaces': {
  65                     'bond1': {
  66                         'type': 'ovs'}}},
  67             'network_empty': {}}
  68
  69     @staticmethod
  70     def expected_is_dpdk():
  71         return False
  72
  73
  74 class DpdkHost(Host):
  75
  76     @property
  77     def _network_profiles(self):
  78         return ['network_dpdk']
  79
  80     @property
  81     def network_profile_details(self):
  82         return {
  83             'network_dpdk': {
  84                 'provider_network_interfaces': {
  85                     'bond1': {
  86                         'type': 'ovs-dpdk'}}}}
  87
  88     @staticmethod
  89     def expected_is_dpdk():
  90         return True
  91
  92
  93 @six.add_metaclass(abc.ABCMeta)
  94 class HostGeneratorBase(object):
  95     """
  96     Abstract generator base for :class:`.Host` instances.
  97
  98     Arguments:
  99        ippool: :class:`IPPool` instance
 100     """
 101     def __init__(self, ippool):
 102         self._ippool = ippool
 103
 104     @property
 105     def _host_cls(self):
 106         return Host
 107
 108     def gen(self, nmbr, service_profiles=None, start=1):
 109         service_profiles = service_profiles or self._default_profiles
 110         for i in range(start, start + nmbr):
 111             yield self._host_cls(
 112                 name='{basename}-{i}'.format(basename=self._basename, i=i),
 113                 service_profiles=service_profiles,
 114                 ippool=self._ippool)
 115
 116     @abc.abstractproperty
 117     def _basename(self):
 118         """Return basename of the host e.g. master"""
 119
 120     @abc.abstractproperty
 121     def _default_profiles(self):
 122         """Return iterable of service profiles"""
 123
 124
 125 class MasterGenerator(HostGeneratorBase):
 126     @property
 127     def _basename(self):
 128         return 'master'
 129
 130     @property
 131     def _default_profiles(self):
 132         return [MasterProfile,
 133                 WorkerProfile,
 134                 StorageProfile,
 135                 BaseProfile,
 136                 ManagementProfile]
 137
 138
 139 class WorkerGenerator(HostGeneratorBase):
 140     @property
 141     def _basename(self):
 142         return 'worker'
 143
 144     @property
 145     def _default_profiles(self):
 146         return [WorkerProfile, BaseProfile]
 147
 148
 149 class StorageGenerator(HostGeneratorBase):
 150     @property
 151     def _basename(self):
 152         return 'storage'
 153
 154     @property
 155     def _default_profiles(self):
 156         return [StorageProfile]
 157
 158
 159 class DpdkWorkerGenerator(WorkerGenerator):
 160     @property
 161     def _host_cls(self):
 162         return DpdkHost