components/openstack/neutron/files/agent/solaris/ra.py
changeset 5405 66fd59fecd68
parent 4975 6445e44cfccd
equal deleted inserted replaced
5404:55e409ba4e72 5405:66fd59fecd68
    17 #    License for the specific language governing permissions and limitations
    17 #    License for the specific language governing permissions and limitations
    18 #    under the License.
    18 #    under the License.
    19 
    19 
    20 import jinja2
    20 import jinja2
    21 import netaddr
    21 import netaddr
    22 from oslo.config import cfg
    22 from oslo_config import cfg
       
    23 from oslo_log import log as logging
    23 import six
    24 import six
    24 
    25 
    25 from neutron.agent.linux import utils
    26 from neutron.agent.linux import utils
    26 from neutron.common import constants
    27 from neutron.common import constants
    27 from neutron.openstack.common import log as logging
       
    28 
    28 
    29 
    29 
    30 LOG = logging.getLogger(__name__)
    30 LOG = logging.getLogger(__name__)
    31 
    31 
    32 OPTS = [
    32 OPTS = [
    58     """\nprefix {{ prefix }} {{ interface_name }} """
    58     """\nprefix {{ prefix }} {{ interface_name }} """
    59     """ AdvOnLinkFlag on AdvAutonomousFlag on """
    59     """ AdvOnLinkFlag on AdvAutonomousFlag on """
    60     """ {% endif %} """)
    60     """ {% endif %} """)
    61 
    61 
    62 
    62 
    63 def _generate_ndpd_conf(router_id, router_ports, dev_name_helper):
    63 class NDPD(object):
    64     ndpd_conf = utils.get_conf_file_name(cfg.CONF.ra_confs, router_id,
    64     """Manage the data and state of Solaris in.ndpd daemon"""
    65                                          'ndpd.conf', True)
       
    66     buf = six.StringIO()
       
    67     for p in router_ports:
       
    68         prefix = p['subnet']['cidr']
       
    69         if netaddr.IPNetwork(prefix).version == 6:
       
    70             interface_name = dev_name_helper(p['id'])
       
    71             ra_mode = p['subnet']['ipv6_ra_mode']
       
    72             buf.write('%s\n' % CONFIG_TEMPLATE.render(
       
    73                 ra_mode=ra_mode,
       
    74                 interface_name=interface_name,
       
    75                 prefix=prefix,
       
    76                 constants=constants))
       
    77 
    65 
    78     utils.replace_file(ndpd_conf, buf.getvalue())
    66     def __init__(self, router_id, dev_name_helper):
    79     return ndpd_conf
    67         self._router_id = router_id
       
    68         self._dev_name_helper = dev_name_helper
    80 
    69 
       
    70     def _generate_ndpd_conf(self, router_ports):
       
    71         ndpd_conf = utils.get_conf_file_name(cfg.CONF.ra_confs,
       
    72                                              self._router_id,
       
    73                                              'ndpd.conf', True)
       
    74         buf = six.StringIO()
       
    75         for p in router_ports:
       
    76             prefix = p['subnets'][0]['cidr']
       
    77             if netaddr.IPNetwork(prefix).version == 6:
       
    78                 interface_name = self._dev_name_helper(p['id'])
       
    79                 ra_mode = p['subnets'][0]['ipv6_ra_mode']
       
    80                 buf.write('%s\n' % CONFIG_TEMPLATE.render(
       
    81                     ra_mode=ra_mode,
       
    82                     interface_name=interface_name,
       
    83                     prefix=prefix,
       
    84                     constants=constants))
    81 
    85 
    82 def _refresh_ndpd(ndpd_conf):
    86         utils.replace_file(ndpd_conf, buf.getvalue())
    83     cmd = ['/usr/sbin/svccfg', '-s', NDP_SMF_FMRI, 'setprop',
    87         return ndpd_conf
    84            'routing/config_file', '=', ndpd_conf]
       
    85     utils.execute(cmd)
       
    86     # this is needed to reflect the routing/config_file property
       
    87     # in svcprop output
       
    88     cmd = ['/usr/sbin/svccfg', '-s', NDP_SMF_FMRI, 'refresh']
       
    89     utils.execute(cmd)
       
    90     # ndpd SMF service doesn't support refresh method, so we
       
    91     # need to restart
       
    92     cmd = ['/usr/sbin/svcadm', 'restart', NDP_SMF_FMRI]
       
    93     utils.execute(cmd)
       
    94     LOG.debug(_("ndpd daemon has been refreshed to re-read the "
       
    95                 "configuration file"))
       
    96 
    88 
       
    89     def _refresh_ndpd(self, ndpd_conf):
       
    90         cmd = ['/usr/sbin/svccfg', '-s', NDP_SMF_FMRI, 'setprop',
       
    91                'routing/config_file', '=', ndpd_conf]
       
    92         utils.execute(cmd)
       
    93         cmd = ['/usr/sbin/svccfg', '-s', NDP_SMF_FMRI, 'refresh']
       
    94         utils.execute(cmd)
       
    95         # ndpd SMF service doesn't support refresh method, so we
       
    96         # need to restart
       
    97         cmd = ['/usr/sbin/svcadm', 'restart', NDP_SMF_FMRI]
       
    98         utils.execute(cmd)
       
    99         LOG.debug(_("ndpd daemon has been refreshed to re-read the "
       
   100                     "configuration file"))
    97 
   101 
    98 def enable_ipv6_ra(router_id, router_ports, dev_name_helper):
   102     def enable(self, router_ports):
    99     for p in router_ports:
   103         for p in router_ports:
   100         if netaddr.IPNetwork(p['subnet']['cidr']).version == 6:
   104             if netaddr.IPNetwork(p['subnets'][0]['cidr']).version == 6:
   101             break
   105                 break
   102     else:
   106         else:
   103         disable_ipv6_ra(router_id)
   107             self.disable()
   104         return
   108             return
   105     LOG.debug("enabling ndpd for router %s", router_id)
   109         LOG.debug("enabling ndpd for router %s", self._router_id)
   106     ndpd_conf = _generate_ndpd_conf(router_id, router_ports, dev_name_helper)
   110         ndpd_conf = self._generate_ndpd_conf(router_ports)
   107     _refresh_ndpd(ndpd_conf)
   111         self._refresh_ndpd(ndpd_conf)
   108 
   112 
       
   113     def disable(self):
       
   114         LOG.debug("disabling ndpd for router %s", self._router_id)
       
   115         utils.remove_conf_files(cfg.CONF.ra_confs, self._router_id)
       
   116         self._refresh_ndpd("")
   109 
   117 
   110 def disable_ipv6_ra(router_id):
   118     @property
   111     LOG.debug("disabling ndpd for router %s", router_id)
   119     def enabled(self):
   112     utils.remove_conf_files(cfg.CONF.ra_confs, router_id)
   120         cmd = ['/usr/bin/svcs', '-H', '-o', 'state', NDP_SMF_FMRI]
   113     _refresh_ndpd("")
   121         stdout = utils.execute(cmd)
       
   122         return 'online' in stdout