jnpr.junos.factory.cfgtable.
CfgTable
(dev=None, xml=None, path=None, mode=None)[source]¶Bases: jnpr.junos.factory.table.Table
__init__
(dev=None, xml=None, path=None, mode=None)[source]¶Dev: | Device instance |
---|---|
Xml: | lxml Element instance |
Path: | file path to XML, to be used rather than :dev: |
append
()[source]¶It creates lxml nodes with field name as xml tag and its value given by user as text of xml node. The generated xml nodes are appended to configuration xml at appropriate hierarchy.
Warning
xml node that are appended cannot be changed later hence care should be taken to assign correct value to table fields before calling append.
get
(*vargs, **kvargs)[source]¶Retrieve configuration data for this table. By default all child keys of the table are loaded. This behavior can be overridden by with kvargs[‘nameonly’]=True
Parameters: |
|
---|
get_table_xml
()[source]¶It returns lxml object of configuration xml that is generated from table data (field=value) pairs. To get a valid xml this method should be used after append() is called.
keys_required
¶True/False - if this Table requires keys
load
(**kvargs)[source]¶Load configuration xml having table data (field=value) in candidate db. This method should be used after append() is called to get the desired results.
Parameters: |
|
---|---|
Returns: | Class object. |
Raises: |
|
required_keys
¶return a list of the keys required when invoking :get(): and :get_keys():
reset
()[source]¶Initialize fields of set table to it’s default value (if mentioned in Table/View) else set to None.
set
(**kvargs)[source]¶Load configuration data in running db. It performs following operation in sequence.
This method should be used after append() is called to get the desired results.
Parameters: |
|
---|---|
Returns: | Class object: |
Raises: |
|
Warning
If the function does not receive a reply prior to the timeout a RpcTimeoutError will be raised. It is possible the commit was successful. Manual verification may be required.
jnpr.junos.factory.factory_cls.
FactoryOpTable
(cmd, args=None, args_key=None, item=None, key='name', view=None, table_name=None)[source]¶jnpr.junos.factory.factory_cls.
FactoryView
(fields, **kvargs)[source]¶Fields: | dictionary of fields, structure of which is ~internal~ and should not be defined explicitly. use the RunstatMaker.Fields() mechanism to create theserather than hardcoding the dictionary structures; since they might change over time. |
---|---|
Kvargs: | ‘view_name’ to name the class. this could be useful for debug or eventual callback mechanisms. ‘groups’ is a dict of name/xpath assocaited to fields this technique would be used to extract fields from node-set elements like port <if-device-flags>. ‘extends’ names the base View class to extend. using this technique you can add to existing defined Views. |
This file contains the FactoryLoader class that is used to dynamically create Runstat Table and View objects from a <dict> of data. The <dict> can originate from any kind of source: YAML, JSON, program. For examples of YAML refer to the .yml files in this jnpr.junos.op directory.
jnpr.junos.factory.factory_loader.
FactoryLoader
[source]¶Bases: object
Used to load a <dict> of data that contains Table and View definitions.
The primary method is :load(): which will return a <dict> of item-name and item-class definitions.
If you want to import these definitions directly into your namespace, (like a module) you would do the following:
loader = FactoryLoader() catalog = loader.load( <catalog_dict> ) globals().update( catalog )
If you did not want to do this, you can access the items as the catalog. For example, if your <catalog_dict> contained a Table called MyTable, then you could do something like:
MyTable = catalog[‘MyTable’] table = MyTable(dev) table.get() …
jnpr.junos.factory.optable.
OpTable
(dev=None, xml=None, path=None)[source]¶Bases: jnpr.junos.factory.table.Table
get
(*vargs, **kvargs)[source]¶Retrieve the XML table data from the Device instance and returns back the Table instance - for call-chaining purposes.
If the Table was created with a :path: rather than a Device, then this method will load the XML from that file. In this case, the *vargs, and **kvargs are not used.
ALIAS: __call__
Vargs: | [0] is the table :arg_key: value. This is used so that the caller can retrieve just one item from the table without having to know the Junos RPC argument. |
---|---|
Kvargs: | these are the name/value pairs relating to the specific Junos XML command attached to the table. For example, if the RPC is ‘get-route-information’, there are parameters such as ‘table’ and ‘destination’. Any valid RPC argument can be passed to :kvargs: to further filter the results of the :get(): operation. neato! |
jnpr.junos.factory.table.
Table
(dev=None, xml=None, path=None)[source]¶Bases: object
D
¶the Device instance
ITEM_NAME_XPATH
= 'name'¶ITEM_XPATH
= None¶RPC
¶the Device.rpc instance
VIEW
= None¶__init__
(dev=None, xml=None, path=None)[source]¶Dev: | Device instance |
---|---|
Xml: | lxml Element instance |
Path: | file path to XML, to be used rather than :dev: |
hostname
¶is_container
¶True if this table does not have records, but is a container of fields False otherwise
key_list
¶the list of keys, as property for caching
savexml
(path, hostname=False, timestamp=False, append=None)[source]¶Save a copy of the table XML data to a local file. The name of the output file (:path:) can include the name of the Device host, the timestamp of this action, as well as any user-defined appended value. These ‘add-ons’ will be added to the :path: value prior to the file extension in the order (hostname,timestamp,append), separated by underscore (_).
For example, if both hostname=True and append=’BAZ1’, then when :path: = ‘/var/tmp/foo.xml’ and the Device.hostname is “srx123”, the final file-path will be “/var/tmp/foo_srx123_BAZ1.xml”
Path: | file-path to write the XML file on the local filesystem |
---|---|
Hostname: | if True, will append the hostname to the :path: |
Timestamp: |
|
Append: | any <str> value that you’d like appended to the :path: value preceding the filename extension. |
view
¶returns the current view assigned to this table
jnpr.junos.factory.view.
View
(table, view_xml)[source]¶Bases: object
View is the base-class that makes extracting values from XML data appear as objects with attributes.
D
¶return the Device instance for this View
FIELDS
= {}¶GROUPS
= None¶ITEM_NAME_XPATH
= 'name'¶T
¶return the Table instance for the View
__init__
(table, view_xml)[source]¶Table: | instance of the RunstatTable |
---|---|
View_xml: | this should be an lxml etree Elemenet object. This constructor also accepts a list with a single item/XML |
key
¶return the name of view item
name
¶return the name of view item
refresh
()[source]¶~~~ EXPERIMENTAL ~~~ refresh the data from the Junos device. this only works if the table provides an “args_key”, does not update the original table, just this specific view/item
updater
(**kwds)[source]¶provide the ability for subclassing objects to extend the definitions of the fields. this is implemented as a context manager with the form called from the subclass constructor:
- with self.extend() as more:
- more.fields = <dict> more.groups = <dict> # optional
xml
¶returns the XML associated to the item
jnpr.junos.factory.viewfields.
ViewFields
[source]¶Bases: object
Used to dynamically create a field dictionary used with the RunstatView class
astype
(name, xpath=None, astype=<type 'int'>, **kvargs)[source]¶field string value will be passed to function :astype:
This is typically used to do simple type conversions, but also works really well if you set :astype: to a function that does a basic converstion like look at the value and change it to a True/False. For example:
astype=lambda x: True if x == ‘enabled’ else False
end
¶flag
(name, xpath=None, **kvargs)[source]¶field is a flag, results in True/False if the xpath element exists or not. Model this as a boolean type <bool>
jnpr.junos.factory.
loadyaml
(path)[source]¶Load a YAML file at :path: that contains Table and View definitions. Returns a <dict> of item-name anditem-class definition.
If you want to import these definitions directly into your namespace, (like a module) you would do the following:
globals().update( loadyaml( <path-to-yaml-file> ))
If you did not want to do this, you can access the items as the <dict>. For example, if your YAML file contained a Table called MyTable, then you could do something like:
catalog = loadyaml( <path-to-yaml-file> ) MyTable = catalog[‘MyTable’]
table = MyTable(dev) table.get() …
jnpr.junos.factory.
FactoryLoader
[source]¶Bases: object
Used to load a <dict> of data that contains Table and View definitions.
The primary method is :load(): which will return a <dict> of item-name and item-class definitions.
If you want to import these definitions directly into your namespace, (like a module) you would do the following:
loader = FactoryLoader() catalog = loader.load( <catalog_dict> ) globals().update( catalog )
If you did not want to do this, you can access the items as the catalog. For example, if your <catalog_dict> contained a Table called MyTable, then you could do something like:
MyTable = catalog[‘MyTable’] table = MyTable(dev) table.get() …