Debian Codegraph @

neutron_vpnaas/services/vpn/plugin.py

raw
1 # (c) Copyright 2013 Hewlett-Packard Development Company, L.P.
2 # All Rights Reserved.
3 #
4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
5 # not use this file except in compliance with the License. You may obtain
6 # a copy of the License at
7 #
8 # http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 # License for the specific language governing permissions and limitations
14 # under the License.
15
16 from neutron.db import servicetype_db as st_db
17 from neutron.services import provider_configuration as pconf
18 from neutron.services import service_base
19 from neutron_lib import context as ncontext
20 from neutron_lib import exceptions as lib_exc
21 from neutron_lib.exceptions import flavors as flav_exc
22 from neutron_lib.plugins import constants
23 from neutron_lib.plugins import directory
24 from oslo_log import log as logging
25
26 from neutron_vpnaas.db.vpn import vpn_db
27 from neutron_vpnaas.extensions import vpn_flavors
28
29 LOG = logging.getLogger(__name__)
30
31
32 def add_provider_configuration(type_manager, service_type):
33 type_manager.add_provider_configuration(
34 service_type,
35 pconf.ProviderConfiguration('neutron_vpnaas', service_type))
36
37
38 class VPNPlugin(vpn_db.VPNPluginDb):
39
40 """Implementation of the VPN Service Plugin.
41
42 This class manages the workflow of VPNaaS request/response.
43 Most DB related works are implemented in class
44 vpn_db.VPNPluginDb.
45 """
46 supported_extension_aliases = ["vpnaas",
47 "vpn-endpoint-groups",
48 "service-type",
49 "vpn-flavors",
50 "vpn-aes-ctr"]
51 path_prefix = "/vpn"
52
53
54 class VPNDriverPlugin(VPNPlugin, vpn_db.VPNPluginRpcDbMixin):
55 """VpnPlugin which supports VPN Service Drivers."""
56 #TODO(nati) handle ikepolicy and ipsecpolicy update usecase
57 def __init__(self):
58 super().__init__()
59 self.service_type_manager = st_db.ServiceTypeManager.get_instance()
60 add_provider_configuration(self.service_type_manager, constants.VPN)
61 # Load the service driver from neutron.conf.
62 self.drivers, self.default_provider = service_base.load_drivers(
63 constants.VPN, self)
64 self._check_orphan_vpnservice_associations()
65 # Associate driver names to driver objects
66 for driver_name, driver in self.drivers.items():
67 driver.name = driver_name
68 LOG.info(("VPN plugin using service drivers: %(service_drivers)s, "
69 "default: %(default_driver)s"),
70 {'service_drivers': self.drivers.keys(),
71 'default_driver': self.default_provider})
72 vpn_db.subscribe()
73
74 @property
75 def _flavors_plugin(self):
76 return directory.get_plugin(constants.FLAVORS)
77
78 def start_rpc_listeners(self):
79 servers = []
80 for driver_name, driver in self.drivers.items():
81 if hasattr(driver, 'start_rpc_listeners'):
82 servers.extend(driver.start_rpc_listeners())
83 return servers
84
85 def _check_orphan_vpnservice_associations(self):
86 context = ncontext.get_admin_context()
87 vpnservices = self.get_vpnservices(context)
88 vpnservice_ids = [vpnservice['id'] for vpnservice in vpnservices]
89
90 stm = self.service_type_manager
91 provider_names = stm.get_provider_names_by_resource_ids(
92 context, vpnservice_ids)
93
94 lost_providers = set()
95 lost_vpnservices = []
96 for vpnservice_id, provider in provider_names.items():
97 if provider not in self.drivers:
98 lost_providers.add(provider)
99 lost_vpnservices.append(vpnservice_id)
100 if lost_providers or lost_vpnservices:
101 # Provider are kept internally, we need to inform users about
102 # the related VPN services.
103 msg = (
104 "Delete associated vpnservices %(vpnservices)s before "
105 "removing providers %(providers)s."
106 ) % {'vpnservices': lost_vpnservices,
107 'providers': list(lost_providers)}
108 LOG.exception(msg)
109 raise SystemExit(msg)
110
111 # Deal with upgrade. Associate existing VPN services to default
112 # provider.
113 unasso_vpnservices = [
114 vpnservice_id for vpnservice_id in vpnservice_ids
115 if vpnservice_id not in provider_names]
116 if unasso_vpnservices:
117 LOG.info(
118 ("Associating VPN services %(unasso_vpnservices)s to "
119 "default provider %(default_provider)s."),
120 {'unasso_vpnservices': unasso_vpnservices,
121 'default_provider': self.default_provider})
122 for vpnservice_id in unasso_vpnservices:
123 stm.add_resource_association(
124 context, constants.VPN,
125 self.default_provider, vpnservice_id)
126
127 def _get_provider_for_flavor(self, context, flavor_id):
128 if flavor_id:
129 if self._flavors_plugin is None:
130 raise vpn_flavors.FlavorsPluginNotLoaded()
131
132 fl_db = self._flavors_plugin.get_flavor(context, flavor_id)
133 if fl_db['service_type'] != constants.VPN:
134 raise lib_exc.InvalidServiceType(
135 service_type=fl_db['service_type'])
136 if not fl_db['enabled']:
137 raise flav_exc.FlavorDisabled()
138 providers = self._flavors_plugin.get_flavor_next_provider(
139 context, fl_db['id'])
140 provider = providers[0].get('provider')
141 if provider not in self.drivers:
142 raise vpn_flavors.NoProviderFoundForFlavor(flavor_id=flavor_id)
143 else:
144 # Use default provider
145 provider = self.default_provider
146
147 LOG.debug("Selected provider %s", provider)
148 return provider
149
150 def _get_driver_for_vpnservice(self, context, vpnservice):
151 stm = self.service_type_manager
152 provider_names = stm.get_provider_names_by_resource_ids(
153 context, [vpnservice['id']])
154 provider = provider_names.get(vpnservice['id'])
155 return self.drivers[provider]
156
157 def _get_driver_for_ipsec_site_connection(self, context,
158 ipsec_site_connection):
159 # Only vpnservice_id is required as the vpnservice should be already
160 # associated with a provider after its creation.
161 vpnservice = {'id': ipsec_site_connection['vpnservice_id']}
162 return self._get_driver_for_vpnservice(context, vpnservice)
163
164 def create_ipsec_site_connection(self, context, ipsec_site_connection):
165 driver = self._get_driver_for_ipsec_site_connection(
166 context, ipsec_site_connection['ipsec_site_connection'])
167 driver.validator.validate_ipsec_site_connection(
168 context,
169 ipsec_site_connection['ipsec_site_connection'])
170 ipsec_site_connection = super().create_ipsec_site_connection(
171 context, ipsec_site_connection)
172 driver.create_ipsec_site_connection(context, ipsec_site_connection)
173 return ipsec_site_connection
174
175 def delete_ipsec_site_connection(self, context, ipsec_conn_id):
176 ipsec_site_connection = self.get_ipsec_site_connection(
177 context, ipsec_conn_id)
178 super().delete_ipsec_site_connection(
179 context, ipsec_conn_id)
180 driver = self._get_driver_for_ipsec_site_connection(
181 context, ipsec_site_connection)
182 driver.delete_ipsec_site_connection(context, ipsec_site_connection)
183
184 def update_ipsec_site_connection(
185 self, context,
186 ipsec_conn_id, ipsec_site_connection):
187 old_ipsec_site_connection = self.get_ipsec_site_connection(
188 context, ipsec_conn_id)
189 driver = self._get_driver_for_ipsec_site_connection(
190 context, old_ipsec_site_connection)
191 driver.validator.validate_ipsec_site_connection(
192 context,
193 ipsec_site_connection['ipsec_site_connection'])
194 ipsec_site_connection = super().update_ipsec_site_connection(
195 context,
196 ipsec_conn_id,
197 ipsec_site_connection)
198 driver.update_ipsec_site_connection(
199 context, old_ipsec_site_connection, ipsec_site_connection)
200 return ipsec_site_connection
201
202 def create_vpnservice(self, context, vpnservice):
203 provider = self._get_provider_for_flavor(
204 context, vpnservice['vpnservice'].get('flavor_id'))
205 vpnservice = super().create_vpnservice(context, vpnservice)
206 self.service_type_manager.add_resource_association(
207 context, constants.VPN, provider, vpnservice['id'])
208 driver = self.drivers[provider]
209 driver.create_vpnservice(context, vpnservice)
210 return vpnservice
211
212 def update_vpnservice(self, context, vpnservice_id, vpnservice):
213 old_vpn_service = self.get_vpnservice(context, vpnservice_id)
214 new_vpn_service = super().update_vpnservice(context, vpnservice_id,
215 vpnservice)
216 driver = self._get_driver_for_vpnservice(context, old_vpn_service)
217 driver.update_vpnservice(context, old_vpn_service, new_vpn_service)
218 return new_vpn_service
219
220 def delete_vpnservice(self, context, vpnservice_id):
221 vpnservice = self._get_vpnservice(context, vpnservice_id)
222 super().delete_vpnservice(context, vpnservice_id)
223 driver = self._get_driver_for_vpnservice(context, vpnservice)
224 self.service_type_manager.del_resource_associations(
225 context, [vpnservice_id])
226 driver.delete_vpnservice(context, vpnservice)