o y.e~@sddlZddlZddlZddlZddlmmZddlZddl Zddl Zddl Zddl Zddl ZddlmZddlmZejdZdZdZdZdZdZd Zd Zd Zd Zed dZdej_Gddde Z!Gdddej"Z#Gddde$Z%Gddde$Z&Gddde$Z'Gddde$Z(ddZ)ej*Gddde$Z+d d!Z,d"d#Z-Gd$d%d%e$Z.Gd&d'd'e$Z/Gd(d)d)e$Z0dS)*N) custom_index)erroridlzno-classattr no-objattrscreateupdatedelete clusteredrelayNotice)eventrowupdatesNcsLeZdZdZdZfddZddZddZd d Zd d Z d dZ Z S)ColumnDefaultDictaA column dictionary with on-demand generated default values This object acts like the Row._data column dictionary, but without the necessity of populating column default values. These values are generated on-demand and therefore only use memory once they are accessed. )_tablecs||_tdSr)rsuper__init__selftable __class__,/usr/lib/python3/dist-packages/ovs/db/idl.pyr;szColumnDefaultDict.__init__cCs|jj|}tjjj|jSr)rcolumnsovsdbdataDatumdefaulttypercolumnrrr __missing__?s zColumnDefaultDict.__missing__cCs |jjSr)rrkeysrrrrr&C zColumnDefaultDict.keyscstfddDS)Nc3s|]}|VqdSrr).0kr'rr Gsz+ColumnDefaultDict.values..)iterr'rr'rvaluesFzColumnDefaultDict.valuescCs t|Sr)r,r&r'rrr__iter__Ir(zColumnDefaultDict.__iter__cCs ||vSr)r&)ritemrrr __contains__Lr(zColumnDefaultDict.__contains__) __name__ __module__ __qualname____doc__ __slots__rr%r&r-r/r1 __classcell__rrrrr2s rc@seZdZeZeZeZdS)MonitorN) r2r3r4 OVSDB_UPDATEmonitor OVSDB_UPDATE2 monitor_cond OVSDB_UPDATE3monitor_cond_sincerrrrr8Psr8c@sxeZdZddZddZeddZeddZed d Zed d Z e d dZ ddZ ddZ ddZddZdS)ConditionStatecCsdg|_d|_d|_dSNT) _ack_cond _req_cond _new_condr'rrrrWs zConditionState.__init__cCst|j|j|jgSr)r,rCrBrAr'rrrr/\zConditionState.__iter__cC|jS)z/The latest freshly initialized condition changerCr'rrrnew_zConditionState.newcCrE)z>The last condition change that has been accepted by the server)rAr'rrrackeddrHzConditionState.ackedcCrE)z>A condition that's been requested, but not acked by the server)rBr'rrr requestedirHzConditionState.requestedcCstdd|DS)z The most recent condition changecss|] }|dur|VqdSrr)r)condrrrr+qsz(ConditionState.latest..)nextr'rrrlatestnszConditionState.latestcCs |dgkSr@r) conditionrrris_trues zConditionState.is_truecCs ||_dS)z1Signal that a condition change is being initiatedNrF)rrKrrrinitwrPzConditionState.initcC"|jdur|jd|_|_dSdS)z-Signal that a condition change has been ackedN)rBrAr'rrrack{ zConditionState.ackcCrR)z1Signal that a condition change has been requestedN)rCrBr'rrrrequestrTzConditionState.requestcCs*|jdur|jdur|j|_d|_dSdS)z.Reset a requested condition change back to newNTF)rBrCr'rrrresets  zConditionState.resetN)r2r3r4rr/propertyrGrIrJrM staticmethodrOrQrSrUrVrrrrr?Vs"      r?c@sNeZdZddZddZeddZeddZejd dZe d d Z d S) IdlTablecCsTt|tjjjs J||_d|_t||_ ||_ t |_ dd|j D|_ dS)NFcSsi|] \}}|t|qSr) IdlColumnr)r*vrrr sz%IdlTable.__init__..) isinstancerrschema TableSchemar need_tabler IndexedRowsrowsrr?_condition_stateritems)rrrrrrrs zIdlTable.__init__cC t|j|Sr)getattrrrattrrrr __getattr__r(zIdlTable.__getattr__cCrEr)rdr'rrrcondition_staterHzIdlTable.condition_statecCs|jjSr)rkrMr'rrrrNszIdlTable.conditioncCs"t|tsJ|j|j|dSr)r^listr cond_changename)rrNrrrrNscsfdd|jDS)Ncsi|] \}}||qSrrr[clsrrrr]sz*IdlTable.schema_tables..)tablesre)rprr_rror schema_tableszIdlTable.schema_tablesN) r2r3r4rrjrWrkrNsetter classmethodrrrrrrrYs    rYc@seZdZddZddZdS)rZcCs||_d|_dSr@)_columnalertr#rrrr zIdlColumn.__init__cCrfr)rgrvrhrrrrjr(zIdlColumn.__getattr__N)r2r3r4rrjrrrrrZs rZc@seZdZdZdZdZdZdZdZdZ dZ e j ee j ee je iZ dkd d Zd dZddZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Z d-d.Z!d/d0Z"d1d2Z#d3d4Z$dld5d6Z%d7d8Z&d9d:Z'd;d<Z(d=d>Z)d?d@Z*dAdBZ+dCdDZ,dEdFZ-dGdHZ.dIdJZ/e jfdKdLZ0dMdNZ1dOdPZ2dldQdRZ3dSdTZ4dUdVZ5dWdXZ6dYdZZ7d[d\Z8d]d^Z9d_d`Z:dadbZ;dcddZdidjZ?d S)mIdla Open vSwitch Database Interface Definition Language (OVSDB IDL). The OVSDB IDL maintains an in-memory replica of a database. It issues RPC requests to an OVSDB database server and parses the responses, converting raw JSON into data structures that are easier for clients to digest. The IDL also assists with issuing database transactions. The client creates a transaction, manipulates the IDL data structures, and commits or aborts the transaction. The IDL then composes and issues the necessary JSON-RPC requests and reports to the client whether the transaction completed successfully. The client is allowed to access the following attributes directly, in a read-only fashion: - 'tables': This is the 'tables' map in the ovs.db.schema.DbSchema provided to the Idl constructor. Each ovs.db.schema.TableSchema in the map is annotated with a new attribute 'rows', which is a dict from a uuid.UUID to a Row object. The client may directly read and write the Row objects referenced by the 'rows' map values. Refer to Row for more details. - 'change_seqno': A number that represents the IDL's state. When the IDL is updated (by Idl.run()), its value changes. The sequence number can occasionally change even if the database does not. This happens if the connection to the database drops and reconnects, which causes the database contents to be reloaded even if they didn't change. (It could also happen if the database server sends out a "change" that reflects what the IDL already thought was in the database. The database server is not supposed to do that, but bugs could in theory cause it to do so.) - 'lock_name': The name of the lock configured with Idl.set_lock(), or None if no lock is configured. - 'has_lock': True, if the IDL is configured to obtain a lock and owns that lock, and False otherwise. Locking and unlocking happens asynchronously from the database client's point of view, so the information is only useful for optimization (e.g. if the client doesn't have the lock then there's no point in trying to write to the database). - 'is_lock_contended': True, if the IDL is configured to obtain a lock but the database server has indicated that some other client already owns the requested lock, and False otherwise. - 'txn': The ovs.db.idl.Transaction object for the database transaction currently being constructed, if there is one, or None otherwise. rrr NTcCs t|tsJ|}t|||_|j|_||_||}t j j j ||d|_ d|_d|_d|_d|_t|_ttjdd|_d|_d|_d|_d|_d|_d|_d|_d|_t|_||_ d|_!d|_"|j#|_$d|_%d|_&d|_'d|_(d|_)i|_*d|_+d|_,dS)a4Creates and returns a connection to the database named 'db_name' on 'remote', which should be in a form acceptable to ovs.jsonrpc.session.open(). The connection will maintain an in-memory replica of the remote database. 'remote' can be comma separated multiple remotes and each remote should be in a form acceptable to ovs.jsonrpc.session.open(). 'schema_helper' should be an instance of the SchemaHelper class which generates schema for the remote database. The caller may have cut it down by removing tables or columns that are not of interest. The IDL will only replicate the tables and columns that remain. The caller may also add an attribute named 'alert' to selected remaining columns, setting its value to False; if so, then changes to those columns will not be considered changes to the database for the purpose of the return value of Idl.run() and Idl.change_seqno. This is useful for columns that the IDL's client will write but not read. As a convenience to users, 'schema' may also be an instance of the SchemaHelper class. The IDL uses and modifies 'schema' directly. If 'leader_only' is set to True (default value) the IDL will only monitor and transact with the leader of the cluster. If "probe_interval" is zero it disables the connection keepalive feature. If non-zero the value will be forced to at least 1000 milliseconds. If None it will just use the default value in OVS. )probe_intervalNrint_ServerDatabaseF)-r^ SchemaHelperget_idl_schemarYrrrqreadonly_db_parse_remotesrjsonrpcSession open_multiple_session _request_id_monitor_request_id _last_seqno change_seqnouuiduuid1strUUIDlast_id_server_schema_request_id_server_monitor_request_id_db_change_aware_request_id_monitor_cancel_request_id_server_db_name_server_db_table server_tables _server_dbserver_monitor_uuid leader_only cluster_id _min_index IDL_S_INITIALstate lock_namehas_lockis_lock_contended_lock_request_idtxn_outstanding_txns cond_changed cond_seqno)rremote schema_helperr~rr_remotesrrrrsH!     z Idl.__init__cCsJg}|dD]}|r|ddkr|dd|7<q||q|S)N,:)splitfindappend)rrrrrrrrGs  zIdl._parse_remotescCs"||_|j|jkr|dSdS)z8Set the id of the cluster that this idl must connect to.N)rrrforce_reconnect)rrrrrset_cluster_idTs  zIdl.set_cluster_idcCs|j|j|S)z,Create a named multi-column index on a table)rqrc index_create)rrrnrrrrZszIdl.index_createcCs|j|jj|||S)z9Return items in a named index between start/end inclusiverqrcindexesirange)rrrnstartendrrr index_irange^rszIdl.index_irangecCs|j|jj|||S)z.Return items in a named index matching a valuer)rrrnvaluerrr index_equalbrszIdl.index_equalcCs|jdS)zNCloses the connection to the database. The IDL will no longer update.N)rcloser'rrrrfsz Idl.closecCs|jD]}|jqdS)z,Mark all requested table conditions as ackedN)rqr-rkrSrrrrack_conditionsks zIdl.ack_conditionscCsp|jttjddk}|rd|_|jD] }|r$|j|j q|j r5ttjdd|_d|_qdS)aSynchronize condition state when the FSM is restarted If a non-zero last_id is available for the DB, then upon reconnect the IDL should first request acked conditions to avoid missing updates about records that were added before the transaction with txn-id == last_id. If there were requested condition changes in flight and the IDL client didn't set new conditions, then reset the requested conditions to new to trigger a follow-up monitor_cond_change request. If there were changes in flight then there are two cases: a. either the server already processed the requested monitor condition change but the FSM was restarted before the client was notified. In this case the client should clear its local cache because it's out of sync with the monitor view on the server side. b. OR the server hasn't processed the requested monitor condition change yet. As there's no easy way to differentiate between the two, and given that this condition should be rare, reset the 'last_id', essentially flushing the local cached DB contents. rrFTN) rrrrrrqr-rkrUrSrV)rack_allrrrrsync_conditionsps   zIdl.sync_conditionscCs|||j|_dSr)r _Idl__send_server_schema_requestIDL_S_SERVER_SCHEMA_REQUESTEDrr'rrr restart_fsms zIdl.restart_fsmc Csl|jrJ|j}||jd}|dkr|d7}|j}|js&n|j}||jkrD||_|| |j rB| nm|j }|durOnb|j tjjjtjjjfv}|rj|jrj|j|jkrjd|_|j tjjjkr|jdkrt|jdkr||jdt|jd|_n|j tjjjkr|jdkrt|jdkr||jdtn|j tjjjkr|jd krt|jdkr|jdt|jkr|j|jdt|j d ||_|!s|"n̐n||jdtn|#|rn|$|rn|j tjjjkr|j%dur|j%|jkrzY|jd7_d|_%|j&|j'krC|j(ds3|)||j(dt|j(d|_n'|j&|j*krV|)||j(tn|j&|j+ks_J|)||j(t|j,|_&Wn<t-j.y}zt/0d |j1|f|2WYd}~nd}~ww|j tjjjkr|j3dur|j3|jkrz$d|_3t4d|j(}|5|j6|7} | |_8t9:|| |_ |;Wnt-j.y}z)t/0d |j1|f|j<r|2WYd}~n||_|=WYd}~nd}~ww|j tjjjkr~|j>dur~|j>|jkr~z(d|_>|j|j(t|j d ||_|!r=|=|?n|"WnmWnft-j.y}}z)t/0d |j1|f|j<rk|2WYd}~nF||_|=WYd}~n4d}~ww|j tjjjkr|j@dur|j@|jkrd|_@n|j tjjjkr|jAdur|jA|jkr|B|j(n|j tjjjkr|jd kr|C|jdn|j tjjjkr|jdkr|C|jdn|j tjjjkr|jdkrn|j tjjjkr|j&|j'kr|j%|jkr|j-dkr|=tDjEn|j tjjjkr<|j&|j*kr<|j%|jkr<|j-dkr;|=tDjFnq|j tjjjkrf|j3durf|j3|jkrfd|_3|j<r^|"nS||_|=nG|j tjjjtjjjfvr{|G|r{n2|j tjjjkr|j&|j,kr|H||jId7_Int/Jd|j1tjjK|j f|dks||jkS)a+Processes a batch of messages from the database server. Returns True if the database as seen through the IDL changed, False if it did not change. The initial fetch of the entire contents of the remote database is considered to be one kind of change. If the IDL has been configured to acquire a database lock (with Idl.set_lock()), then successfully acquiring the lock is also considered to be a change. This function can return occasional false positives, that is, report that the database changed even though it didn't. This happens if the connection to the database drops and reconnects, which causes the database contents to be reloaded even if they didn't change. (It could also happen if the database server sends out a "change" that reflects what we already thought was in the database, but the database server is not supposed to do that.) As an alternative to checking the return value, the client may check for changes in self.change_seqno.r2rNupdate3rzr update2r)rqz&%s: parse error in received schema: %sz%%s: error receiving server schema: %slockedTstolenFechozunknown methodz"%s: received unexpected %s message)Lrrsend_cond_changerrun is_connected get_seqnor_Idl__txn_abort_allrr_Idl__send_lock_requestrecvr"rrMessageT_REPLYT_ERRORridT_NOTIFYmethodlenparams_Idl__parse_updater=rr;rrr9r_Idl__check_server_dbrhandle_monitor_canceledhandle_monitor_cancel_replyrr'IDL_S_DATA_MONITOR_COND_SINCE_REQUESTEDresult _Idl__clear!IDL_S_DATA_MONITOR_COND_REQUESTEDIDL_S_DATA_MONITOR_REQUESTEDIDL_S_MONITORINGrErrorvlogerrget_name _Idl__errorrrregister_tablerrrrYrr!_Idl__send_server_monitor_requestr_Idl__send_monitor_requestr_Idl__send_db_change_awarerr_Idl__parse_lock_reply_Idl__parse_lock_notifyr8r<r:_Idl__txn_process_replyrrdbgtype_to_string) rinitial_change_seqnoiprevious_change_seqnoseqnomsg is_responseeshr_rrrrst                                      ;zIdl.runcCs|j|jkrdS|jdkrdS|jdt|jkr t|jg}n|jdt|jkr1t|jg}ndStjj d|}|j |_ | ||dS)NFmonitor_canceledrmonitor_cancelT)r"rrrrrrrrrcreate_requestrr send_requestr)rrrmc_msgrrrrps   zIdl.handle_monitor_canceledcCs*|j|jkrdS|j|jkrdSd|_dS)NFT)r"rrrrrrrrrs  zIdl.handle_monitor_cancel_replycCs|jsdSi}|jD]}|jjdur#d|jjig||j<|jq |s(dSd|_t|j}t |_|t|j|g}t j j d|S)NwhereFmonitor_cond_change)rrqr-rkrGrnrUrrrrrrr)rchange_requestsrold_uuidrrrrcompose_cond_changes$     zIdl.compose_cond_changecCs6|jr |jdur dS|}|r||dSdSr)rrrrrrrrrrs zIdl.send_cond_changecCs|j|}|std||gkrdg}|jj|kr%|j|d|_|jjr>t dd|j D}|j t |dS|j t t |jjS)aGSets the condition for 'table_name' to 'cond', which should be a conditional expression suitable for use directly in the OVSDB protocol, with the exception that the empty condition [] matches no rows (instead of matching every row). That is, [] is equivalent to [False], not to [True]. zUnknown table "%s"FTcss|]}|jjVqdSr)rkrU)r)trrrr+sz"Idl.cond_change..r)rqgetrrrkrMrQrrGanyr-rrboolrJ)r table_namerKrany_reqsrrrrms   zIdl.cond_changecCs.|jr |dS|j||j|dS)zArranges for poller.block() to wake up when self.run() has something to do or when activity occurs on a transaction on 'self'.N)rimmediate_wakerwait recv_waitrpollerrrrrs  zIdl.waitcCs |jdkS)aReturns True, if the IDL successfully connected to the remote database and retrieved its contents (even if the connection subsequently dropped and is in the process of reconnecting). If so, then the IDL contains an atomic snapshot of the database's contents (but it might be arbitrarily old if the connection dropped). Returns False if the IDL has never connected or retrieved the database's contents. If so, the IDL is empty.r)rr'rrrhas_ever_connecteds zIdl.has_ever_connectedcCs$|j|jkr |j|jdS)zForces the IDL to drop its connection to the database and reconnect. In the meantime, the contents of the IDL will not change.N)rrr reset_backoffrr'rrrrs  zIdl.force_reconnectcCs |jSr)rrr'rrr session_names zIdl.session_namecCs`|jrJ|jr J|jr|r||jkr|d|_d|_|r,|js.||_|dSdSdS)aMIf 'lock_name' is not None, configures the IDL to obtain the named lock from the database server and to avoid modifying the database when the lock cannot be acquired (that is, when another client has the same lock). If 'lock_name' is None, drops the locking requirement and releases the lock.NF)rrr_Idl__send_unlock_requestrr)rrrrrset_locks    z Idl.set_lockcCdS)aHook for implementing create/update/delete notifications :param event: The event that was triggered :type event: ROW_CREATE, ROW_UPDATE, or ROW_DELETE :param row: The row as it is after the operation has occured :type row: Row :param updates: For updates, row with only old values of the changed columns :type updates: Row Nr)rr rrrrrnotifyz Idl.notifycCr)awHook for cooperatively yielding to eventlet/gevent/asyncio/etc. When a block of code is going to spend a lot of time cpu-bound without doing any I/O, it can cause greenthread/coroutine libraries to block. This call should be added to code where this can happen, but defaults to doing nothing to avoid overhead where it is not needed. Nrr'rrrcooperative_yieldrzIdl.cooperative_yieldcCsJd}|jD] }|jrd}t||_qd|_|r#|jd7_dSdS)NFTrr)rqr-rcrrbrr)rchangedrrrr__clears z Idl.__clearcCs6|r|js|jdur|jd7_n d|_||_dS)NrF)rrrr)r new_has_lockrrr__update_has_lock&s   zIdl.__update_has_lockcCsL|dd|_|jr"tjj||jg}|j }|j ||Sd}|S)NF) _Idl__update_has_lockrrrrrrrrrsend)rrrmsg_idrrr__do_send_lock_request2s   zIdl.__do_send_lock_requestcCs|d|_dS)Nlock)_Idl__do_send_lock_requestrr'rrr__send_lock_request=szIdl.__send_lock_requestcCs|ddS)Nunlock)r$r'rrr__send_unlock_request@zIdl.__send_unlock_requestcCs:d|_t|to|ddu}|||sd|_dSdS)NrT)rr^dictrrr)rrgot_lockrrr__parse_lock_replyCs   zIdl.__parse_lock_replycCsV|jdur!t|ttfr#|r%|d|jkr'|||s)d|_dSdSdSdSdSdS)NrT)rr^rltuplerr)rrrrrr__parse_lock_notifyJs     zIdl.__parse_lock_notifycCs*tjjddg}|j|_|j|dS)Nset_db_change_awareT)rrrrrrrr rrrr__send_db_change_awareSs zIdl.__send_db_change_awarecCs"|j|_|jr|j|SdSr)rrrrr )rrUrrrrYs  zIdl.send_requestc Cs0|j|jkr |j|_d}n|j|jkr!|jt||_t|j}n|j|_d}i}|j D]@}g}|j D]}|j|j vsM|j|j vrR||j |jvrR| |q7d|i}|dvrht|jjsh|jj|d<|g||j<q.|jjt|j|g}|dkr| t|jtjj||} | j|_|| dS)Nr<r:r)r<r>rr>)rrrIDL_S_SERVER_MONITOR_REQUESTED monitor_mapr8rnrrqr-rr&rrr?rOrkrIrrrrrrrrrrr) r max_versionrmonitor_requestsrrr$monitor_requestargsrrrr__send_monitor_request^s:        zIdl.__send_monitor_requestcCs:|j|_tjjd|jt|jg}|j |_ | |dS)N get_schema) rrrrrrrrrrrrrrrr__send_server_schema_request~s z Idl.__send_server_schema_requestcCs|j|_i}|j|j}dd|jD}|jD] }t|ds%d|_qt ||_ d|_ ||_ d|i}|g||j<tjjd|jjt|j|g}|j|_||dS)NcSsg|]}|qSrr)r)r$rrr z5Idl.__send_server_monitor_request..rwTFrr:)r0rrrrr&r-hasattrrwrrbrcrarrnrrrrrrrrrr)rr3rrr$r4rrrr__send_server_monitor_requests*    z!Idl.__send_server_monitor_requestc Cspz|s||||jWdS||||WdStjy7}ztd|j|fWYd}~dSd}~ww)Nz%s: error parsing update: %s)_Idl__do_parse_updaterqrrrrrr)rrversionrqrrrr__parse_updates zIdl.__parse_updatecCst|ts td|g}|D]\}}||}|s#td|t|ts0td|||D]\}} tj|sHtd||f|tj |} t| ts\td||f| |t t fvr|| || | } | r{|| |jd7_q4tjj| d} | dtg} | d tg}| | s|std | ||| | |} | r|| |jd7_q4q|D]}|j|qdS) Nz is not an objectz+ includes unknown table "%s"z. for table "%s" is not an objectzC for table "%s" contains bad UUID "%s" as member namezP for table "%s" contains for %s that is not an objectrz row-updateoldrGz, missing "old" and "new" members)r^r)rrrerrovsuuidis_valid_string from_stringrr;r=_Idl__process_update2rrrparserParser get_optionalfinish_Idl__process_updater)r table_updatesr>rqnoticesr  table_updater uuid_string row_updaterchangesrEr@rGnoticerrr__do_parse_updatesj         $ zIdl.__do_parse_updatecCs|j|}d|vr!|r|j|=tt|Std||jfd Sd|vs)d|vrg|r9td||jf|j|=|||}d|vrH|d}n|d}|||| |||}||j|<|rett |Sd Sd|vr|srt d| |||d}tt|t||||St d|) 4Returns Notice if a column changed, False otherwise.rz)cannot delete missing row %s from table%sinsertinitialz(cannot add existing row %s from table %smodifyzModify non-existing rowz unknown operationF)rcrr ROW_DELETErwarnrn_Idl__create_row_Idl__add_default_Idl__row_update ROW_CREATErr_Idl__apply_diff ROW_UPDATERow)rrrrNrrold_rowrrr__process_update2sB         zIdl.__process_update2c Cs"|j|}d}|s!|r|j|=tt|Std||jfdS|sWt}|s0|||}d}n t }td||jf|| |||O}|tkrN||j|<|rUtt|SdSt }|so|||}d}t}td||jf|| |||O}|tkr||j|<|rt||t ||||SdS)rRFz*cannot delete missing row %s from table %sTz&cannot add existing row %s to table %sz(cannot modify missing row %s in table %s) rcrr rVrrWrnr[rXr]rZr^ from_json)rrrr@rGrroprrr__process_updatesN        zIdl.__process_updatecCs|}|j|jvrtd||j|jfdS|j|jj}d}|D] }|jr:|jt dd|j vr9|}n q%|j |j j krE|}nq%|sUtd||j j fdS|j tkr|jsftd|dS|jsrtd|dS|jr|jstd |dS|jr|jd |jkrtd |dS|jd |_dS|j tkr|jstd |dS|jstd |dS|jrtd|dSdS)zAReturns True if this is a valid server database, False otherwise.z4%s: server does not have %s table in its %s databaseFNcSst|ddS)Nr{r)xrrr<r:z'Idl.__check_server_db..z$%s: server does not have %s databasezO%s: clustered database server has not yet joined cluster; trying another serverzQ%s: clustered database server is disconnected from cluster; trying another serverzJ%s: clustered database server is not cluster leader; trying another serverrzC%s: clustered database server has stale data; trying another serverzZ%s: relay database server has not yet connected to the relay source; trying another serverzV%s: relay database server is disconnected from the relay source; trying another serverzC%s: relay database server cannot be a leader; trying another serverT)rrrrinforrcr-rmapcidrnrmodel CLUSTEREDr_ connectedrleaderindexrrWRELAY)rrrcdatabaserrrr__check_server_db,s      zIdl.__check_server_dbcCs4|jjjtjjjkrtj|jjjjS|jjjjSr) r"keyrrtypesUuidTyperAto_jsonr!r#rrr __column_namens zIdl.__column_namecCsn|jD]/}|j|vr4|j|jvs!|j|jvr4|j|j|jvr4|jjdkr4|js4||||j<qdS)Nr)rr-rnrr"n_minis_map_Idl__column_name)rrrNr$rrr __add_defaultts   zIdl.__add_defaultc Csi}|D]]\}}|j|}|std||jfqz tj|j |}Wnt j yE} ztd||j| fWYd} ~ qd} ~ ww|j | ||<|j ||} | |j |krc| |j |<q|S)N#unknown column %s updating table %s'error parsing column %s in table %s: %s)rerrrrWrnrr rar"rr_datacopydiff) rrrrow_diffr_ column_namedatum_diff_jsonr$ datum_diffrdatumrrr __apply_diff}s.    zIdl.__apply_diffc Csd}|D]S\}}|j|}|std||jfqz tj|j |}Wnt j yE} ztd||j| fWYd} ~ qd} ~ ww||j |krX||j |<|j rWd}q q|S)NFr{r|T)rerrrrWrnrr rar"rrr}rw) rrrrow_jsonrr datum_jsonr$rrrrr __row_updates0    zIdl.__row_updatecCst|||t|Sr)r^r)rrrrrr __create_rowszIdl.__create_rowcCs|jdSr)rrr'rrr__errorr(z Idl.__errorcCs*|jr|jd}tj|_|jsdSdS)Nr)rpopitem Transaction TRY_AGAIN_status)rrrrr__txn_abort_allszIdl.__txn_abort_allcCs&|j|jd}|r||dSdSr@)rpopr_process_reply)rrrrrr__txn_process_replys  zIdl.__txn_process_replyr@r)@r2r3r4r5rrr0rrrrr8r:r<r>r1rrrrrrrrrrrrrrrrmrrrrrrrrrr$rrrrrrrrrrr=rDrIrryrYr\rZrXrrrrrrrrys3 N $U            7%-B  rycCst|tr|jS|Sr)r^r^r)rrrr _row_to_uuids rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZd%ddZeddZddZdd Zd!d"Zd#d$ZdS)&r^aA row within an IDL. The client may access the following attributes directly: - 'uuid': a uuid.UUID object whose value is the row's database UUID. - An attribute for each column in the Row's table, named for the column, whose values are as returned by Datum.to_python() for the column's type. If some error occurs (e.g. the database server's idea of the column is different from the IDL's idea), then the attribute values is the "default" value return by Datum.default() for the column's type. (It is important to know this because the default value may violate constraints for the column's type, e.g. the default integer value is 0 even if column contraints require the column's value to be positive.) When a transaction is active, column attributes may also be assigned new values. Committing the transaction will then cause the new value to be stored into the database. *NOTE*: In the current implementation, the value of a column is a *copy* of the value in the database. This means that modifying its value directly will have no useful effect. For example, the following: row.mycolumn["a"] = "b" # don't do this will not change anything in the database, even after commit. To modify the column, instead assign the modified column value back to the column: d = row.mycolumn d["a"] = "b" row.mycolumn = d cCsJ||jd<||jd<||jd<||jd<i|jd<i|jd<i|jd<dS)Nr_idlrr}_changes _mutations_prereqs)__dict__)rrrrrrrrrs     z Row.__init__cCs&t|tstSt|jd|jdkSNrr^r^NotImplementedr rrotherrrr__lt__" z Row.__lt__cCs&t|tstSt|jd|jdkSrrrrrr__eq__'rz Row.__eq__cCst|jdSr)rrr'rrr__hash__,r(z Row.__hash__cs.djjjdfddtjjDdS)Nz{table}({data})z, c3s.|]}t|rdj|t|dVqdS)z {col}={val})colvalN)r;formatrgr)cr'rrr+2s zRow.__str__..)rr)rrrnjoinsortedrr'rr'r__str__/s  z Row.__str__c Cs\|jr,z |jj|jj}Wnty%}z d|jj}t||d}~ww|j|S|S)NzTable {} is not registered) ref_tablerrqrnKeyErrorrAttributeErrorrcr)ratombaserrrrrr _uuid_to_row6s  zRow._uuid_to_rowc s|jdusJ|jdusJz|jj|}Wnty'td|jj|fw|j|}d}d|j vr?|jd|}d}d|j vrP|jd|}|dur|j durq|durgtd|jj|ft j |j|t}n||j vr|j |}|jr|}|dur|t||durt j |j|t}|fdd|D}t j |j|t}nC|jr||j}|dur|||dur|D]} | |pivr|| dqt j |j|t}n|durtd|jj|f|}||jS)Nz!%s instance has no attribute '%s'_inserts_removescsg|]}|vr|qSrr)r)re removes_listrrr9fsz#Row.__getattr__..)rrrrrrrr2rr&r}rr from_pythonr"ris_setas_listextendrlrx to_pythonrrr) rrr$rinsertsremovesdlist removes_datumdmaprrrrrrjAs                 zRow.__getattr__c Cs2|jdusJ|jjs J|jj|jjvr(||jj|jjvr(td|dS|jj|}z t j |j |t }WntjyV}ztd||fWYd}~dSd}~wwt||ru|jjjD]}|dd|jDvrt||qc|jj||||jjjD]}|dd|jDvr||qdS)Nz)attempting to write to readonly column %s/attempting to write bad value to column %s (%s)cs|]}|jVqdSrr$rrrrr+z"Row.__setattr__..csrrrrrrrr+r)rrrrrnrrrWrrr rr"rrrrr;rcrr-remove_writeadd)rrrr$rridxrrr __setattr__}s:     zRow.__setattr__c C||jjj|j<|jj|}z tj|j |t Wnt j y6}zt d||fWYd}~dSd}~ww|jdi}||t}||dS)Nrrrr _txn_rowsrrrrr rr"rrrrrr setdefaultsetr)rrrrr$rr column_valuerrraddvalue z Row.addvaluec Cr)Nz2attempting to delete bad value from column %s (%s)rr)rrrrr$rrrrrrdelvaluerz Row.delvaluec Cs||jjj|j<|jj|}z tj|j ||it Wnt j y8}zt d||fWYd}~dSd}~ww|jrT||jvrT|jdi}||t}|||jdi}||i}|||<dS)Nrrr)rrrrrrrr rr"rrrrrr}rrrr) rrrrrr$rrrrrrrsetkeys$    z Row.setkeyNcCs||jjj|j<|r1z tj|j||j}Wn t j y"YdSw||vr)dS|||kr1dS|j di}| |t }||dS)Nr)rrrrrr rr}rrrrrrr)rrrrr old_valuerrrrrdelkeys"  z Row.delkeyc Csi}|D]F\}}|j|}|std||jfqz tjjj |j |} Wnt j yG} ztd||j| fWYd} ~ qd} ~ ww| ||<q|||||S)Nzunknown column %s in table %sr|)rerrrrWrnrrrr rar"rr) rprrrrrrrr$rrrrrras&    z Row.from_jsoncCs@|jjsJ|jdus J|jdus||jvrdSd|j|<dS)aCauses the original contents of column 'column_name' in this row to be verified as a prerequisite to completing the transaction. That is, if 'column_name' changed in this row (or if this row was deleted) between the time that the IDL originally read its contents and the time that the transaction commits, then the transaction aborts and Transaction.commit() returns Transaction.TRY_AGAIN. The intention is that, to ensure that no transaction commits based on dirty reads, an application should call Row.verify() on each data item read as part of a read-modify-write operation. In some cases Row.verify() reduces to a no-op, because the current value of the column is already known: - If this row is a row created by the current transaction (returned by Transaction.insert()). - If the column has already been modified within the current transaction. Because of the latter property, always call Row.verify() *before* modifying the column, for a given read-modify-write. A transaction must be in progress.N)rrrr}rrrrrrverifys z Row.verifycCs^|jjsJ|jdus J|jdur|jjj|j=n||jjj|j<|jj|j=d|jd<dS)zLDeletes this row from its table. A transaction must be in progress.Nr) rrrr}rrrrcrr'rrrrs   z Row.deletecCs|jj||dSr)rr_fetchrrrrfetchrDz Row.fetchcCs|jj||dS)aCauses the transaction, when committed, to increment the value of 'column_name' within this row by 1. 'column_name' must have an integer type. After the transaction commits successfully, the client may retrieve the final (incremented) value of 'column_name' with Transaction.get_increment_new_value(). The client could accomplish something similar by reading and writing and verify()ing columns. However, increment() will never (by itself) cause a transaction to fail because of a verify error. The intended use is for incrementing the "next_cfg" column in the Open_vSwitch table.N)rr _incrementrrrr increments z Row.incrementr)r2r3r4r5rrrrrrrjrrrrrrurarrrrrrrrr^s(7 <    r^cCsdt|ddS)Nzrow%s-_)rreplacerrrr_uuid_name_from_uuid/rDrcCsdddt|gggS)N_uuid==rrdrrrr_where_uuid_equals3rDrc@seZdZddZdS) _InsertedRowcCs||_d|_dSr)op_indexreal)rrrrrr8rxz_InsertedRow.__init__N)r2r3r4rrrrrr7s rc@seZdZdZdZdZdZdZdZdZ dZ d Z e d d Z d d ZddZddZddZddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd7d+d,Zd-d.Ze d/d0Zd1d2Z d3d4Z!d5d6Z"d*S)8ra A transaction may modify the contents of a database by modifying the values of columns, deleting rows, inserting rows, or adding checks that columns in the database have not changed ("verify" operations), through Row methods. Reading and writing columns and inserting and deleting rows are all straightforward. The reasons to verify columns are less obvious. Verification is the key to maintaining transactional integrity. Because OVSDB handles multiple clients, it can happen that between the time that OVSDB client A reads a column and writes a new value, OVSDB client B has written that column. Client A's write should not ordinarily overwrite client B's, especially if the column in question is a "map" column that contains several more or less independent data items. If client A adds a "verify" operation before it writes the column, then the transaction fails in case client B modifies it first. Client A will then see the new value of the column and compose a new transaction based on the new contents written by client B. When a transaction is complete, which must be before the next call to Idl.run(), call Transaction.commit() or Transaction.abort(). The life-cycle of a transaction looks like this: 1. Create the transaction and record the initial sequence number: seqno = idl.change_seqno(idl) txn = Transaction(idl) 2. Modify the database with Row and Transaction methods. 3. Commit the transaction by calling Transaction.commit(). The first call to this function probably returns Transaction.INCOMPLETE. The client must keep calling again along as this remains true, calling Idl.run() in between to let the IDL do protocol processing. (If the client doesn't have anything else to do in the meantime, it can use Transaction.commit_block() to avoid having to loop itself.) 4. If the final status is Transaction.TRY_AGAIN, wait for Idl.change_seqno to change from the saved 'seqno' (it's possible that it's already changed, in which case the client should not wait at all), then start over from step 1. Only a call to Idl.run() will change the return value of Idl.change_seqno. (Transaction.commit_block() calls Idl.run().) uncommitted unchanged incompleteabortedsuccessz try againz not lockedrcCs|S)zConverts one of the status values that Transaction.commit() can return into a human-readable string. (The status values are in fact such strings already, so there's nothing to do.)r)statusrrrstatus_to_stringszTransaction.status_to_stringcCs\|jdusJ||_d|_||_d|_i|_tj|_d|_g|_ d|_ d|_ g|_ i|_ dS)a[Starts a new transaction on 'idl' (an instance of ovs.db.idl.Idl). A given Idl may only have a single active transaction at a time. A Transaction may modify the contents of a database by assigning new values to columns (attributes of Row), deleting rows (with Row.delete()), or inserting rows (with Transaction.insert()). It may also check that columns in the database have not changed with Row.verify(). When a transaction is complete (which must be before the next call to Idl.run()), call Transaction.commit() or Transaction.abort().NF)rrrdry_runrr UNCOMMITTEDr_error _comments_inc_row _inc_column_fetch_requests_inserted_rows)rrrrrrs  zTransaction.__init__cCs|j|dS)aAppends 'comment' to the comments that will be passed to the OVSDB server when this transaction is committed. (The comment will be committed to the OVSDB log, which "ovsdb-tool show-log" can print in a relatively human-readable form.)N)rr)rcommentrrr add_commentszTransaction.add_commentcCs"|jtjtjfvr|dSdS)zTCauses poll_block() to wake up if this transaction has completed committing.N)rrr INCOMPLETEr rrrrrs  zTransaction.waitcst|ttfrBt|dkr9|ddkr9tj|dr9tj|d}j |d}|r7|j dur7dt |gS|Sfdd|DS|S)Nr rrrz named-uuidcsg|]}|qSr)_substitute_uuids)r)elemr'rrr9sz1Transaction._substitute_uuids..) r^rlr,rrrArBrCrrr}r)rjsonrrrr'rrs   zTransaction._substitute_uuidscCsd|j_|jD]3}|jdur"i|jd<i|jd<||jj|j<n |j dur-|jj|j=i|jd<i|jd<i|jd<q i|_dS)Nrrr) rrrr-rrrrcrr})rrrrr __disassembles         zTransaction.__disassemblec Cs||jjkr |jS|jjtjkrtj|_||jS|jj r.|jj s.tj |_||jS|jj j g}|jj rB|d|jj d|jD]0}|jrwi}g}|jD]}|||j|||<qS|d|jj dt|jd||gdqGd}|jD]}|jdur|jjr|d |jj t|jd d }n| nz|jrd |jj i}|jdurd |d<t|j|d<d }t|d}t||j|j<n d|d<t|j|d<i} | |d<|jD]*\}} |jdus| s || | |<|s |jdur |j|| kr d }q|jdus| r|||j r2d} d |jj i}d|d<|jdur9|t|j|d<nt|j|d<g|d<d|j !vr|j dD]_\} } |jj"| }|j#$rndg}|t%| n5dg}g}| D](}z t&j'(|j#|t)} Wnt*j+yYdSw||| qu||| d |g}|d|d } qSd|j !vr(|j dD]e\} }|jj"| }|j#$rt&j'(|j#|t)} || }n5dg}g}|D](}z t&j'(|j#|t)} Wnt*j+yYdSw||| q||| d |g}|d|d } q| r2||d }q|j,ra|j,D]$}t|d|d<|d|djj |t|dj|dgdq:d }|j-r|rt|d|_.|d|j-jj |t|j-j|j/ddggd|d|j-jj |t|j-j|j/gd|j0r|dd 1|j0d!|j2r|dd"i|stj3|_n$t4j5j67d#|}|j8|_9|jj:;|s||jj<|j9<tj=|_ntj|_||jS)$aAttempts to commit 'txn'. Returns the status of the commit operation, one of the following constants: Transaction.INCOMPLETE: The transaction is in progress, but not yet complete. The caller should call again later, after calling Idl.run() to let the IDL do OVSDB protocol processing. Transaction.UNCHANGED: The transaction is complete. (It didn't actually change the database, so the IDL didn't send any request to the database server.) Transaction.ABORTED: The caller previously called Transaction.abort(). Transaction.SUCCESS: The transaction was successful. The update made by the transaction (and possibly other changes made by other database clients) should already be visible in the IDL. Transaction.TRY_AGAIN: The transaction failed for some transient reason, e.g. because a "verify" operation reported an inconsistency or due to a network problem. The caller should wait for a change to the database, then compose a new transaction, and commit the new transaction. Use Idl.change_seqno to wait for a change in the database. It is important to use its value *before* the initial call to Transaction.commit() as the baseline for this purpose, because the change that one should wait for can happen after the initial call but before the call that returns Transaction.TRY_AGAIN, and using some other baseline value in that situation could cause an indefinite wait if the database rarely changes. Transaction.NOT_LOCKED: The transaction failed because the IDL has been configured to require a database lock (with Idl.set_lock()) but didn't get it yet or has already lost it. Committing a transaction rolls back all of the changes that it made to the IDL's copy of the database. If the transaction commits successfully, then the database server will send an update and, thus, the IDL will be updated with the committed changes.assert)rbr#rrr)rbrtimeoutruntilrrcFNr)rbrrTrrSrbz uuid-namerrrrmutate mutationsrrrrnselectr)rbrrrz+=)rbrrrr )rbraborttransact)>rrrrryrrr_Transaction__disassemblerr NOT_LOCKEDrrnrrr-rr}rurrrris_rootrrrrre is_defaultrrr&rr"rxrlrr rrrrrr _inc_indexrrrr UNCHANGEDrrrrrrrr rr)r operationsrrcrr any_updatesrbrrraddoprdatr$opdat inner_opdatelemutationrrrrrrcommitsP 5                                       zTransaction.commitcCsL |}|tjkr |S|jtj}|j|||| q)aIAttempts to commit this transaction, blocking until the commit either succeeds or fails. Returns the final commit status, which may be any Transaction.* value other than Transaction.INCOMPLETE. This function calls Idl.run() on this transaction'ss IDL, so it may cause Idl.change_seqno to change.) rrrrrrrPollerrblock)rrrrrr commit_blocks     zTransaction.commit_blockcCs|jtjksJ|jS)zReturns the final (incremented) value of the column in this transaction that was set to be incremented by Row.increment. This transaction must have committed successfully.)rrSUCCESS_inc_new_valuer'rrrget_increment_new_valuesz#Transaction.get_increment_new_valuecCs*||jtjtjfvrtj|_dSdS)zAborts this transaction. If Transaction.commit() has already been called then the transaction might get committed anyhow.N)rrrrrABORTEDr'rrrrs  zTransaction.abortcCs(|jtjkr t|jS|jr|jSdS)zjReturns a string representing this transaction's current status, suitable for use in log messages.zno error details available)rrERRORrrr'rrr get_errors  zTransaction.get_errorcCs |jdurtj||_dSdSr)rrr to_string)rrrrr__set_error_jsons zTransaction.__set_error_jsoncCs0|jtjtjfvs J|j|}|r|jSdS)aXFinds and returns the permanent UUID that the database assigned to a newly inserted row, given the UUID that Transaction.insert() assigned locally to that row. Returns None if 'uuid' is not a UUID assigned by Transaction.insert() or if it was assigned by that function and then deleted by Row.delete() within the same transaction. (Rows that are inserted and then deleted within a single transaction are never sent to the database server, so it never assigns them a permanent UUID.) This transaction must have completed successfully.N)rrrrrrr)rr inserted_rowrrrget_insert_uuids  zTransaction.get_insert_uuidcCs|jrJ||_||_dSr)rr)rrr$rrrrs  zTransaction._incrementcCs|j||ddS)N)rr)rr)rrrrrrr r.zTransaction._fetchcCs|jdusJ|jdusJ|jj}|js4|jdur4|j|j|kr4|j|j}|dus2||kr4dS||j|j <d|jvrI|jd |jdd|jvrX|jd |jd| |j|j<dS)Nrr) rrrrrwr}rrnrrrr~)rrr$rr new_valuerrrr s   zTransaction._writeNcCsL|jtjksJ|durt}t|j||d}||j|j<||j|j<|S)a3Inserts and returns a new row in 'table', which must be one of the ovs.db.schema.TableSchema objects in the Idl's 'tables' dict. The new row is assigned a provisional UUID. If 'uuid' is None then one is randomly generated; otherwise 'uuid' should specify a randomly generated uuid.UUID not otherwise in use. ovsdb-server will assign a different UUID when 'txn' is committed, but the IDL will replace any uses of the provisional UUID in the data to be to be committed by the UUID assigned by ovsdb-server.N) rrrruuid4r^rrcr)rrnew_uuidrrrrrS,s   zTransaction.insertc Csp|jtjjjkrtj|_dSt|j t t fst ddSd}d}d}|j }|D]>}|dur1d}q(t|trZ|d}|durY|dkrFd}q(|dkrMd}q(|dkrRq(d}||q(d}||t dq(|s|s|s|jrw||swd}|jr||r|jjd 7_nd}|jD] }|||sd}q|rtj|_dS|rtj|_dS|rtj|_dStj|_dS) Nz%reply to "transact" is not JSON arrayFTrz timed outz not ownerrz*operation reply is not JSON null or objectr)r"rrrrrrrr^rrlr,rrWr)r_Transaction__set_error_jsonr_Transaction__process_inc_replyr!_Transaction__process_fetch_replyrrrr-"_Transaction__process_insert_replyrrr) rr hard_errors soft_errors lock_errorsopsrbrrSrrrr>sX             zTransaction._process_replycCsB|s td|dSt|t|std|t|fdSdS)Nz %s is missingFz%s has unexpected type %sT)rrWr^r,r")rrsrnrrr__check_json_typexszTransaction.__check_json_typecCsd}|jD]]}|d}|d}|d}|j}||}|d} t| ttfds+dSt| dkr;t dt| q| d } t| t fd sHq|j |} | |} t j | j| } | |j|<d }q|S) NFrrrnrc"select" reply "rows"r2"select" reply "rows" has %d elements instead of 1r"select" reply rowT)rrrr_Transaction__check_json_typerlr,rrrWr)rrr rar"r})rr)r fetch_requestrrrnrr fetched_rows fetched_rowr$rrrrr__process_fetch_replys8        z!Transaction.__process_fetch_replycCs|jdt|krtdt||jdf||j}|d}t|tfds+dS|dkr8td|dS||jd}|d}t|tt fd sOdSt|dkr`td t|dS|d }t|t fd sndS||j }t|tfd s~dS||_ dS)Nr zIreply does not contain enough operations for increment (has %d, needs %d)countz"mutate" reply "count"Frz)"mutate" reply "count" is %d instead of 1rcr+r,rr-z"select" reply inc columnT) rrrrWrrr.rrlr,r)rr)rr)rr3rrcrr$rrr__process_inc_replysH         zTransaction.__process_inc_replycCs|jt|krtdt||jfdS||j}|d}t|ttfds*dSzt j |}Wnt j yBtdYdSw||_dS)NzFreply does not contain enough operations for insert (has %d, needs %d)Frz"insert" reply "uuid"z("insert" reply "uuid" is not a JSON UUIDT)rrrrWrrr.r,rlrrArarrr)rrSr)reply json_uuiduuid_rrr__process_insert_replys&     z"Transaction.__process_insert_replyr)#r2r3r4r5rrrrrrrrrXrrrrrrrrrrrr"rrrrrSrr.r$r#r%rrrrr=sF.  q  :   (rc@sFeZdZdZdddZgfddZddZd d Zd d Zd dZ dS)raIDL Schema helper. This class encapsulates the logic required to generate schemas suitable for creating 'ovs.db.idl.Idl' objects. Clients should register columns they are interested in using register_columns(). When finished, the get_idl_schema() function may be called. The location on disk of the schema used may be found in the 'schema_location' variable.NcCsT|r|rtd|dur|durdtjj}tj|}||_i|_i|_d|_ dS)zCreates a new Schema object. 'location' file path to ovs schema. None means default location 'schema_json' schema in json preresentation in memory zAboth location and schema_json can't be specified. it's ambiguous.Nz%s/vswitch.ovsschemaF) ValueErrorrdirs PKGDATADIRr from_file schema_json_tables _readonly_all)rlocationr=rrrrs   zSchemaHelper.__init__cCsLt|tsJt|tsJt||j|tB}||j|<||j|<dS)a,Registers interest in the given 'columns' of 'table'. Future calls to get_idl_schema() will include 'table':column for each column in 'columns'. This function automatically avoids adding duplicate entries to the schema. A subset of 'columns' can be specified as 'readonly'. The readonly columns are not replicated but can be fetched on-demand by the user with Row.fetch(). 'table' must be a string. 'columns' must be a list of strings. 'readonly' must be a list of strings. N)r^rrlrr>rr?)rrrrrrrregister_columns s  zSchemaHelper.register_columnscCst|tsJt|j|<dS)zRegisters interest in the given all columns of 'table'. Future calls to get_idl_schema() will include all columns of 'table'. 'table' must be a string N)r^rrr>rrrrr szSchemaHelper.register_tablecCs d|_dS)z2Registers interest in every column of every table.TN)r@r'rrr register_all% rPzSchemaHelper.register_allcCsZtjjj|j}d|_|js'i}|jD] \}}| |||||<q||_ |j |_ |S)zGets a schema appropriate for the creation of an 'ovs.db.id.IDL' object based on columns registered using the register_columns() function.N) rrr_DbSchemarar=r@r>re_keep_table_columnsrqr?r)rr_rrrrrrrr) s zSchemaHelper.get_idl_schemacCsb||jvsJ|j|}|s|Si}|D]}t|tsJ||jvs$J|j|||<q||_|Sr)rqr^rr)rr_r rr new_columnsrrrrrE; s z SchemaHelper._keep_table_columns)NN) r2r3r4r5rrBrrCrrErrrrrs   r)1 collectionsenum functoolsr ovs.db.datarr ovs.db.parserr ovs.db.schema ovs.jsonrpc ovs.ovsuuid ovs.pollerovs.vlogovs.dbrrrVlog __pychecker__r[r]rVr9r;r=rkro namedtupler __new__ __defaults__r)rIntEnumr8objectr?rYrZryrtotal_orderingr^rrrrrrrrrsl    9  e0