← Back to branch summary

~ubuntu-branches/ubuntu/vivid/neutron/vivid-updates

« back to all changes in this revision

Viewing changes to neutron/plugins/bigswitch/routerrule_db.py

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2015-03-30 11:17:19 UTC
  • mfrom: (1.1.21)
  • Revision ID: package-import@ubuntu.com-20150330111719-h0gx7233p4jkkgfh
Tags: 1:2015.1~b3-0ubuntu1
https://launchpad.net/bugs/1263539
* New upstream milestone release:
  - d/control: Align version requirements with upstream.
  - d/control: Add new dependency on oslo-log.
  - d/p/*: Rebase.
  - d/control,d/neutron-plugin-hyperv*: Dropped, decomposed into
    separate project upstream.
  - d/control,d/neutron-plugin-openflow*: Dropped, decomposed into
    separate project upstream.
  - d/neutron-common.install: Add neutron-rootwrap-daemon and 
    neutron-keepalived-state-change binaries.
  - d/rules: Ignore neutron-hyperv-agent when installing; only for Windows.
  - d/neutron-plugin-cisco.install: Drop neutron-cisco-cfg-agent as
    decomposed into separate project upstream.
  - d/neutron-plugin-vmware.install: Drop neutron-check-nsx-config and
    neutron-nsx-manage as decomposed into separate project upstream.
  - d/control: Add dependency on python-neutron-fwaas to neutron-l3-agent.
* d/pydist-overrides: Add overrides for oslo packages.
* d/control: Fixup type in package description (LP: #1263539).
* d/p/fixup-driver-test-execution.patch: Cherry pick fix from upstream VCS
  to support unit test exection in out-of-tree vendor drivers.
* d/neutron-common.postinst: Allow general access to /etc/neutron but limit
  access to root/neutron to /etc/neutron/neutron.conf to support execution
  of unit tests in decomposed vendor drivers.
* d/control: Add dependency on python-neutron-fwaas to neutron-l3-agent
  package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
neutron/plugins/bigswitch/routerrule_db.py
13
13
#    License for the specific language governing permissions and limitations
14
14
#    under the License.
15
15
 
16
 
from oslo.config import cfg
17
16
import sqlalchemy as sa
18
17
from sqlalchemy import orm
19
18
 
20
 
from neutron.db import l3_db
21
19
from neutron.db import model_base
22
 
from neutron.openstack.common import log as logging
23
 
from neutron.plugins.bigswitch.extensions import routerrule
24
 
 
25
 
 
26
 
LOG = logging.getLogger(__name__)
27
20
 
28
21
 
29
22
class RouterRule(model_base.BASEV2):
43
36
                                      ondelete="CASCADE"),
44
37
                        primary_key=True)
45
38
    nexthop = sa.Column(sa.String(64), nullable=False, primary_key=True)
46
 
 
47
 
 
48
 
class RouterRule_db_mixin(l3_db.L3_NAT_db_mixin):
49
 
    """Mixin class to support route rule configuration on a router."""
50
 
    def update_router(self, context, id, router):
51
 
        r = router['router']
52
 
        with context.session.begin(subtransactions=True):
53
 
            router_db = self._get_router(context, id)
54
 
            if 'router_rules' in r:
55
 
                self._update_router_rules(context,
56
 
                                          router_db,
57
 
                                          r['router_rules'])
58
 
            updated = super(RouterRule_db_mixin, self).update_router(
59
 
                context, id, router)
60
 
            updated['router_rules'] = self._get_router_rules_by_router_id(
61
 
                context, id)
62
 
 
63
 
        return updated
64
 
 
65
 
    def create_router(self, context, router):
66
 
        r = router['router']
67
 
        with context.session.begin(subtransactions=True):
68
 
            router_db = super(RouterRule_db_mixin, self).create_router(
69
 
                context, router)
70
 
            if 'router_rules' in r:
71
 
                self._update_router_rules(context,
72
 
                                          router_db,
73
 
                                          r['router_rules'])
74
 
            else:
75
 
                LOG.debug('No rules in router')
76
 
            router_db['router_rules'] = self._get_router_rules_by_router_id(
77
 
                context, router_db['id'])
78
 
 
79
 
        return router_db
80
 
 
81
 
    def _update_router_rules(self, context, router, rules):
82
 
        if len(rules) > cfg.CONF.ROUTER.max_router_rules:
83
 
            raise routerrule.RulesExhausted(
84
 
                router_id=router['id'],
85
 
                quota=cfg.CONF.ROUTER.max_router_rules)
86
 
        del_context = context.session.query(RouterRule)
87
 
        del_context.filter_by(router_id=router['id']).delete()
88
 
        context.session.expunge_all()
89
 
        LOG.debug('Updating router rules to %s', rules)
90
 
        for rule in rules:
91
 
            router_rule = RouterRule(
92
 
                router_id=router['id'],
93
 
                destination=rule['destination'],
94
 
                source=rule['source'],
95
 
                action=rule['action'])
96
 
            router_rule.nexthops = [NextHop(nexthop=hop)
97
 
                                    for hop in rule['nexthops']]
98
 
            context.session.add(router_rule)
99
 
        context.session.flush()
100
 
 
101
 
    def _make_router_rule_list(self, router_rules):
102
 
        ruleslist = []
103
 
        for rule in router_rules:
104
 
            hops = [hop['nexthop'] for hop in rule['nexthops']]
105
 
            ruleslist.append({'id': rule['id'],
106
 
                              'destination': rule['destination'],
107
 
                              'source': rule['source'],
108
 
                              'action': rule['action'],
109
 
                              'nexthops': hops})
110
 
        return ruleslist
111
 
 
112
 
    def _get_router_rules_by_router_id(self, context, id):
113
 
        query = context.session.query(RouterRule)
114
 
        router_rules = query.filter_by(router_id=id).all()
115
 
        return self._make_router_rule_list(router_rules)
116
 
 
117
 
    def get_router(self, context, id, fields=None):
118
 
        with context.session.begin(subtransactions=True):
119
 
            router = super(RouterRule_db_mixin, self).get_router(
120
 
                context, id, fields)
121
 
            router['router_rules'] = self._get_router_rules_by_router_id(
122
 
                context, id)
123
 
            return router
124
 
 
125
 
    def get_routers(self, context, filters=None, fields=None,
126
 
                    sorts=None, limit=None, marker=None,
127
 
                    page_reverse=False):
128
 
        with context.session.begin(subtransactions=True):
129
 
            routers = super(RouterRule_db_mixin, self).get_routers(
130
 
                context, filters, fields, sorts=sorts, limit=limit,
131
 
                marker=marker, page_reverse=page_reverse)
132
 
            for router in routers:
133
 
                router['router_rules'] = self._get_router_rules_by_router_id(
134
 
                    context, router['id'])
135
 
            return routers
136
 
 
137
 
    def get_sync_data(self, context, router_ids=None, active=None):
138
 
        """Query routers and their related floating_ips, interfaces."""
139
 
        with context.session.begin(subtransactions=True):
140
 
            routers = super(RouterRule_db_mixin,
141
 
                            self).get_sync_data(context, router_ids,
142
 
                                                active=active)
143
 
            for router in routers:
144
 
                router['router_rules'] = self._get_router_rules_by_router_id(
145
 
                    context, router['id'])
146
 
        return routers