b10df6b8789c907348444c57acc43f181ea35267
[sliver-openvswitch.git] / xenserver / usr_share_openvswitch_scripts_ovs-xapi-sync
1 #!/usr/bin/python
2 # Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks
3 #
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain 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,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16
17 # A daemon to monitor the external_ids columns of the Bridge and
18 # Interface OVSDB tables for changes that require interrogating XAPI.
19 # Its responsibilities include:
20 #
21 #   - Set the "bridge-id" key in the Bridge table.
22 #   - Set the "iface-id" key in the Interface table.
23 #   - Set the fail-mode on internal bridges.
24
25 import argparse
26 import os
27 import signal
28 import sys
29 import time
30
31 import XenAPI
32
33 import ovs.dirs
34 from ovs.db import error
35 from ovs.db import types
36 import ovs.daemon
37 import ovs.db.idl
38
39 root_prefix = ''                # Prefix for absolute file names, for testing.
40 vlog = ovs.vlog.Vlog("ovs-xapi-sync")
41 session = None
42 force_run = False
43
44
45 # Set up a session to interact with XAPI.
46 #
47 # On system start-up, OVS comes up before XAPI, so we can't log into the
48 # session until later.  Try to do this on-demand, since we won't
49 # actually do anything interesting until XAPI is up.
50 def init_session():
51     global session
52     if session is not None:
53         return True
54
55     try:
56         session = XenAPI.xapi_local()
57         session.xenapi.login_with_password("", "")
58     except XenAPI.Failure, e:
59         session = None
60         vlog.warn("Couldn't login to XAPI (%s)" % e)
61         return False
62
63     return True
64
65
66 def get_network_by_bridge(br_name):
67     if not init_session():
68         vlog.warn("Failed to get bridge id %s because"
69                 " XAPI session could not be initialized" % br_name)
70         return None
71
72     for n in session.xenapi.network.get_all():
73         rec = session.xenapi.network.get_record(n)
74         if rec['bridge'] == br_name:
75             return rec
76
77     return None
78
79
80 # By default, the "bridge-id" external id in the Bridge table is the
81 # same as "xs-network-uuids".  This may be overridden by defining a
82 # "nicira-bridge-id" key in the "other_config" field of the network
83 # record of XAPI.  If nicira-bridge-id is undefined returns default.
84 # On error returns None.
85 def get_bridge_id(br_name, default=None):
86     rec = get_network_by_bridge(br_name)
87     if rec:
88         return rec['other_config'].get('nicira-bridge-id', default)
89     return None
90
91
92 # By default, the "iface-id" external id in the Interface table is the
93 # same as "xs-vif-uuid".  This may be overridden by defining a
94 # "nicira-iface-id" key in the "other_config" field of the VIF
95 # record of XAPI.
96 def get_iface_id(if_name, xs_vif_uuid):
97     if not if_name.startswith("vif") and not if_name.startswith("tap"):
98         # Treat whatever was passed into 'xs_vif_uuid' as a default
99         # value for non-VIFs.
100         return xs_vif_uuid
101
102     if not init_session():
103         vlog.warn("Failed to get interface id %s because"
104                 " XAPI session could not be initialized" % if_name)
105         return xs_vif_uuid
106
107     try:
108         vif = session.xenapi.VIF.get_by_uuid(xs_vif_uuid)
109         rec = session.xenapi.VIF.get_record(vif)
110         return rec['other_config'].get('nicira-iface-id', xs_vif_uuid)
111     except XenAPI.Failure:
112         vlog.warn("Could not find XAPI entry for VIF %s" % if_name)
113         return xs_vif_uuid
114
115
116 def set_or_delete(d, key, value):
117     if value is None:
118         if key in d:
119             del d[key]
120             return True
121     else:
122         if d.get(key) != value:
123             d[key] = value
124             return True
125     return False
126
127
128 def set_external_id(row, key, value):
129     external_ids = row.external_ids
130     if set_or_delete(external_ids, key, value):
131         row.external_ids = external_ids
132
133
134 # XenServer does not call interface-reconfigure on internal networks,
135 # which is where the fail-mode would normally be set.
136 def update_fail_mode(row):
137     rec = get_network_by_bridge(row.name)
138     if not rec:
139         return
140
141     fail_mode = rec['other_config'].get('vswitch-controller-fail-mode')
142
143     if not fail_mode:
144         pools = session.xenapi.pool.get_all()
145         if len(pools) == 1:
146             prec = session.xenapi.pool.get_record(pools[0])
147             fail_mode = prec['other_config'].get(
148                     'vswitch-controller-fail-mode')
149
150     if fail_mode not in ['standalone', 'secure']:
151         fail_mode = 'standalone'
152
153     if row.fail_mode != fail_mode:
154         row.fail_mode = fail_mode
155
156
157 def update_in_band_mgmt(row):
158     rec = get_network_by_bridge(row.name)
159     if not rec:
160         return
161
162     dib = rec['other_config'].get('vswitch-disable-in-band')
163
164     other_config = row.other_config
165     if dib and dib not in ['true', 'false']:
166         vlog.warn('"%s" isn\'t a valid setting for '
167                 "other_config:disable-in-band on %s" % (dib, row.name))
168     elif set_or_delete(other_config, 'disable-in-band', dib):
169         row.other_config = other_config
170
171
172 def update_bridge_id(row):
173     id_ = get_bridge_id(row.name, row.external_ids.get("xs-network-uuids"))
174     if not id_:
175         return
176
177     set_external_id(row, "bridge-id", id_.split(";")[0])
178
179
180 def keep_table_columns(schema, table_name, columns):
181     table = schema.tables.get(table_name)
182     if not table:
183         raise error.Error("schema has no %s table" % table_name)
184
185     new_columns = {}
186     for column_name in columns:
187         column = table.columns.get(column_name)
188         if not column:
189             raise error.Error("%s table schema lacks %s column"
190                               % (table_name, column_name))
191         new_columns[column_name] = column
192     table.columns = new_columns
193     return table
194
195
196 def prune_schema(schema):
197     new_tables = {}
198     new_tables["Bridge"] = keep_table_columns(
199         schema, "Bridge", ("name", "external_ids", "other_config",
200                            "fail_mode"))
201     new_tables["Interface"] = keep_table_columns(
202         schema, "Interface", ("name", "external_ids"))
203     schema.tables = new_tables
204
205
206 def handler(signum, _):
207     global force_run
208     if (signum == signal.SIGHUP):
209         force_run = True
210
211
212 def main():
213     global force_run
214
215     parser = argparse.ArgumentParser()
216     parser.add_argument("database", metavar="DATABASE",
217             help="A socket on which ovsdb-server is listening.")
218     parser.add_argument("--root-prefix", metavar="DIR",
219                         help="Use DIR as alternate root directory"
220                         " (for testing).")
221
222     ovs.vlog.add_args(parser)
223     ovs.daemon.add_args(parser)
224     args = parser.parse_args()
225     ovs.vlog.handle_args(args)
226     ovs.daemon.handle_args(args)
227
228     global root_prefix
229     if args.root_prefix:
230         root_prefix = args.root_prefix
231
232     remote = args.database
233     schema_file = "%s/vswitch.ovsschema" % ovs.dirs.PKGDATADIR
234     schema = ovs.db.schema.DbSchema.from_json(ovs.json.from_file(schema_file))
235     prune_schema(schema)
236     idl = ovs.db.idl.Idl(remote, schema)
237
238     ovs.daemon.daemonize()
239
240     # This daemon is usually started before XAPI, but to complete our
241     # tasks, we need it.  Wait here until it's up.
242     cookie_file = root_prefix + "/var/run/xapi_init_complete.cookie"
243     while not os.path.exists(cookie_file):
244         time.sleep(1)
245
246     signal.signal(signal.SIGHUP, handler)
247
248     bridges = {}                # Map from bridge name to xs_network_uuids
249     iface_ids = {}              # Map from xs-vif-uuid to iface-id
250     while True:
251         if not force_run and not idl.run():
252             poller = ovs.poller.Poller()
253             idl.wait(poller)
254             poller.block()
255             continue
256
257         if force_run:
258             vlog.info("Forced to re-run as the result of a SIGHUP")
259             bridges = {}
260             iface_ids = {}
261             force_run = False
262
263         txn = ovs.db.idl.Transaction(idl)
264
265         new_bridges = {}
266         for row in idl.tables["Bridge"].rows.itervalues():
267             old_xnu = bridges.get(row.name)
268             new_xnu = row.external_ids.get("xs-network-uuids", "")
269             if old_xnu is None:
270                 # New bridge.
271                 update_fail_mode(row)
272                 update_in_band_mgmt(row)
273             if new_xnu != old_xnu:
274                 # New bridge or bridge's xs-network-uuids has changed.
275                 update_bridge_id(row)
276             new_bridges[row.name] = new_xnu
277         bridges = new_bridges
278
279         iface_by_name = {}
280         for row in idl.tables["Interface"].rows.itervalues():
281             iface_by_name[row.name] = row
282
283         new_iface_ids = {}
284         for row in idl.tables["Interface"].rows.itervalues():
285             # Match up paired vif and tap devices.
286             if row.name.startswith("vif"):
287                 vif = row
288                 tap = iface_by_name.get("tap%s" % row.name[3:])
289             elif row.name.startswith("tap"):
290                 tap = row
291                 vif = iface_by_name.get("vif%s" % row.name[3:])
292             else:
293                 tap = vif = None
294
295             # Several tap external-ids need to be copied from the vif.
296             if row == tap and vif:
297                 keys = ["attached-mac",
298                         "xs-network-uuid",
299                         "xs-vif-uuid",
300                         "xs-vm-uuid"]
301                 for k in keys:
302                     set_external_id(row, k, vif.external_ids.get(k))
303
304             # Map from xs-vif-uuid to iface-id.
305             #
306             # (A tap's xs-vif-uuid comes from its vif.  That falls out
307             # naturally from the copy loop above.)
308             xvu = row.external_ids.get("xs-vif-uuid")
309             if xvu:
310                 iface_id = (new_iface_ids.get(xvu)
311                             or iface_ids.get(xvu)
312                             or get_iface_id(row.name, xvu))
313                 new_iface_ids[xvu] = iface_id
314             else:
315                 # No xs-vif-uuid therefore no iface-id.
316                 iface_id = None
317             set_external_id(row, "iface-id", iface_id)
318
319             # When there's a vif and a tap, the tap is active (used for
320             # traffic).  When there's just a vif, the vif is active.
321             #
322             # A tap on its own shouldn't happen, and we don't know
323             # anything about other kinds of devices, so we don't use
324             # an iface-status for those devices at all.
325             if vif and tap:
326                 set_external_id(tap, "iface-status", "active")
327                 set_external_id(vif, "iface-status", "inactive")
328             elif vif:
329                 set_external_id(vif, "iface-status", "active")
330             else:
331                 set_external_id(row, "iface-status", None)
332         iface_ids = new_iface_ids
333
334         txn.commit_block()
335
336
337 if __name__ == '__main__':
338     try:
339         main()
340     except SystemExit:
341         # Let system.exit() calls complete normally
342         raise
343     except:
344         vlog.exception("traceback")
345         sys.exit(ovs.daemon.RESTART_EXIT_CODE)