jnpr.junos.factory.cfgtable.
CfgTable
(dev=None, xml=None, path=None)[source]¶Bases: jnpr.junos.factory.table.Table
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: |
|
---|
keys_required
¶True/False - if this Table requires keys
required_keys
¶return a list of the keys required when invoking :get(): and :get_keys():
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
(*args, **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() ...