text: # Copyright 2012-2013 NEC Corporation.  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.
  # @author: Ryota MIBU
  
  from neutron.openstack.common import excutils
  from neutron.openstack.common import log as logging
  from neutron.plugins.nec.common import config
  from neutron.plugins.nec.common import exceptions as nexc
  from neutron.plugins.nec.db import api as ndb
  from neutron.plugins.nec.db import packetfilter as pf_db
  
  
  LOG = logging.getLogger(__name__)
  
  
  class PacketFilterMixin(pf_db.PacketFilterDbMixin):
      """Mixin class to add packet filter to NECPluginV2."""
  
      @property
      def packet_filter_enabled(self):
          if not hasattr(self, '_packet_filter_enabled'):
              self._packet_filter_enabled = (
                  config.OFC.enable_packet_filter and
                  self.ofc.driver.filter_supported())
          return self._packet_filter_enabled
  
      def remove_packet_filter_extension_if_disabled(self, aliases):
          if not self.packet_filter_enabled:
              LOG.debug(_('Disabled packet-filter extension.'))
              aliases.remove('packet-filter')
  
      def create_packet_filter(self, context, packet_filter):
          """Create a new packet_filter entry on DB, then try to activate it."""
          LOG.debug(_("create_packet_filter() called, packet_filter=%s ."),
                    packet_filter)
  
          if hasattr(self.ofc.driver, 'validate_filter_create'):
              pf = packet_filter['packet_filter']
              self.ofc.driver.validate_filter_create(context, pf)
          pf = super(PacketFilterMixin, self).create_packet_filter(
              context, packet_filter)
  
          return self.activate_packet_filter_if_ready(context, pf)
  
      def update_packet_filter(self, context, id, packet_filter):
          """Update packet_filter entry on DB, and recreate it if changed.
  
          If any rule of the packet_filter was changed, recreate it on OFC.
          """
          LOG.debug(_("update_packet_filter() called, "
                      "id=%(id)s packet_filter=%(packet_filter)s ."),
                    {'id': id, 'packet_filter': packet_filter})
  
          pf_data = packet_filter['packet_filter']
          if hasattr(self.ofc.driver, 'validate_filter_update'):
              self.ofc.driver.validate_filter_update(context, pf_data)
  
          # validate ownership
          pf_old = self.get_packet_filter(context, id)
  
          pf = super(PacketFilterMixin, self).update_packet_filter(
              context, id, packet_filter)
  
          def _packet_filter_changed(old_pf, new_pf):
              LOG.debug('old_pf=%(old_pf)s, new_pf=%(new_pf)s',
                        {'old_pf': old_pf, 'new_pf': new_pf})
              # When the status is ERROR, force sync to OFC.
              if old_pf['status'] == pf_db.PF_STATUS_ERROR:
                  LOG.debug('update_packet_filter: Force filter update '
                            'because the previous status is ERROR.')
                  return True
              for key in new_pf:
                  if key in ('id', 'name', 'tenant_id', 'network_id',
                             'in_port', 'status'):
                      continue
                  if old_pf[key] != new_pf[key]:
                      return True
              return False
  
          if _packet_filter_changed(pf_old, pf):
              if hasattr(self.ofc.driver, 'update_filter'):
                  # admin_state is changed
                  if pf_old['admin_state_up'] != pf['admin_state_up']:
                      LOG.debug('update_packet_filter: admin_state '
                                'is changed to %s', pf['admin_state_up'])
                      if pf['admin_state_up']:
                          self.activate_packet_filter_if_ready(context, pf)
                      else:
                          self.deactivate_packet_filter(context, pf)
                  elif pf['admin_state_up']:
                      LOG.debug('update_packet_filter: admin_state is '
                                'unchanged (True)')
                      if self.ofc.exists_ofc_packet_filter(context, id):
                          pf = self._update_packet_filter(context, pf, pf_data)
                      else:
                          pf = self.activate_packet_filter_if_ready(context, pf)
                  else:
                      LOG.debug('update_packet_filter: admin_state is unchanged '
                                '(False). No need to update OFC filter.')
              else:
                  pf = self.deactivate_packet_filter(context, pf)
                  pf = self.activate_packet_filter_if_ready(context, pf)
  
          return pf
  
      def _update_packet_filter(self, context, new_pf, pf_data):
          pf_id = new_pf['id']
          prev_status = new_pf['status']
          try:
              # If previous status is ERROR, try to sync all attributes.
              pf = new_pf if prev_status == pf_db.PF_STATUS_ERROR else pf_data
              self.ofc.update_ofc_packet_filter(context, pf_id, pf)
              new_status = pf_db.PF_STATUS_ACTIVE
              if new_status != prev_status:
                  self._update_resource_status(context, "packet_filter",
                                               pf_id, new_status)
                  new_pf['status'] = new_status
              return new_pf
          except Exception as exc:
              with excutils.save_and_reraise_exception():
                  if (isinstance(exc, nexc.OFCException) or
                      isinstance(exc, nexc.OFCConsistencyBroken)):
                      LOG.error(_("Failed to create packet_filter id=%(id)s on "
                                  "OFC: %(exc)s"),
                                {'id': pf_id, 'exc': exc})
                  new_status = pf_db.PF_STATUS_ERROR
                  if new_status != prev_status:
                      self._update_resource_status(context, "packet_filter",
                                                   pf_id, new_status)
  
      def delete_packet_filter(self, context, id):
          """Deactivate and delete packet_filter."""
          LOG.debug(_("delete_packet_filter() called, id=%s ."), id)
  
          # validate ownership
          pf = self.get_packet_filter(context, id)
  
          # deactivate_packet_filter() raises an exception
          # if an error occurs during processing.
          pf = self.deactivate_packet_filter(context, pf)
  
          super(PacketFilterMixin, self).delete_packet_filter(context, id)
  
      def activate_packet_filter_if_ready(self, context, packet_filter):
          """Activate packet_filter by creating filter on OFC if ready.
  
          Conditions to create packet_filter on OFC are:
              * packet_filter admin_state is UP
              * (if 'in_port' is specified) portinfo is available
          """
          LOG.debug(_("activate_packet_filter_if_ready() called, "
                      "packet_filter=%s."), packet_filter)
  
          pf_id = packet_filter['id']
          in_port_id = packet_filter.get('in_port')
          current = packet_filter['status']
  
          pf_status = current
          if not packet_filter['admin_state_up']:
              LOG.debug(_("activate_packet_filter_if_ready(): skip pf_id=%s, "
                          "packet_filter.admin_state_up is False."), pf_id)
          elif in_port_id and not ndb.get_portinfo(context.session, in_port_id):
              LOG.debug(_("activate_packet_filter_if_ready(): skip "
                          "pf_id=%s, no portinfo for the in_port."), pf_id)
          elif self.ofc.exists_ofc_packet_filter(context, packet_filter['id']):
              LOG.debug(_("_activate_packet_filter_if_ready(): skip, "
                          "ofc_packet_filter already exists."))
          else:
              LOG.debug(_("activate_packet_filter_if_ready(): create "
                          "packet_filter id=%s on OFC."), pf_id)
              try:
                  self.ofc.create_ofc_packet_filter(context, pf_id,
                                                    packet_filter)
                  pf_status = pf_db.PF_STATUS_ACTIVE
              except (nexc.OFCException, nexc.OFCMappingNotFound) as exc:
                  LOG.error(_("Failed to create packet_filter id=%(id)s on "
                              "OFC: %(exc)s"), {'id': pf_id, 'exc': exc})
                  pf_status = pf_db.PF_STATUS_ERROR
  
          if pf_status != current:
              self._update_resource_status(context, "packet_filter", pf_id,
                                           pf_status)
              packet_filter.update({'status': pf_status})
  
          return packet_filter
  
      def deactivate_packet_filter(self, context, packet_filter):
          """Deactivate packet_filter by deleting filter from OFC if exixts."""
          LOG.debug(_("deactivate_packet_filter_if_ready() called, "
                      "packet_filter=%s."), packet_filter)
          pf_id = packet_filter['id']
  
          if not self.ofc.exists_ofc_packet_filter(context, pf_id):
              LOG.debug(_("deactivate_packet_filter(): skip, "
                          "Not found OFC Mapping for packet_filter id=%s."),
                        pf_id)
              return packet_filter
  
          LOG.debug(_("deactivate_packet_filter(): "
                      "deleting packet_filter id=%s from OFC."), pf_id)
          try:
              self.ofc.delete_ofc_packet_filter(context, pf_id)
              self._update_resource_status_if_changed(
                  context, "packet_filter", packet_filter, pf_db.PF_STATUS_DOWN)
              return packet_filter
          except (nexc.OFCException, nexc.OFCMappingNotFound) as exc:
              with excutils.save_and_reraise_exception():
                  LOG.error(_("Failed to delete packet_filter id=%(id)s "
                              "from OFC: %(exc)s"),
                            {'id': pf_id, 'exc': str(exc)})
                  self._update_resource_status_if_changed(
                      context, "packet_filter", packet_filter,
                      pf_db.PF_STATUS_ERROR)
  
      def activate_packet_filters_by_port(self, context, port_id):
          if not self.packet_filter_enabled:
              return
  
          filters = {'in_port': [port_id], 'admin_state_up': [True],
                     'status': [pf_db.PF_STATUS_DOWN]}
          pfs = self.get_packet_filters(context, filters=filters)
          for pf in pfs:
              self.activate_packet_filter_if_ready(context, pf)
  
      def deactivate_packet_filters_by_port(self, context, port_id,
                                            raise_exc=True):
          if not self.packet_filter_enabled:
              return
  
          filters = {'in_port': [port_id], 'status': [pf_db.PF_STATUS_ACTIVE]}
          pfs = self.get_packet_filters(context, filters=filters)
          error = False
          for pf in pfs:
              try:
                  self.deactivate_packet_filter(context, pf)
              except (nexc.OFCException, nexc.OFCMappingNotFound):
                  error = True
          if raise_exc and error:
              raise nexc.OFCException(_('Error occurred while disabling packet '
                                        'filter(s) for port %s'), port_id)
  
      def get_packet_filters_for_port(self, context, port):
          if self.packet_filter_enabled:
              return super(PacketFilterMixin,
                           self).get_packet_filters_for_port(context, port)
  