f5.bigip.tm.gtm¶
Module contents¶
BIG-IP® Global Traffic Manager™ (GTM®) module.
- REST URI
http://localhost/mgmt/tm/gtm/
- GUI Path
DNS
- REST Kind
tm:gtm:*
Submodule List¶
datacenter |
BIG-IP® Global Traffic Manager (GTM) datacenter module. |
global_settings |
BIG-IP® Global Traffic Manager™ (GTM®) global-settings submodule. |
listener |
BIG-IP® Global Traffic Manager™ (GTM®) Topology Records module. |
pool |
BIG-IP® Global Traffic Manager™ (GTM®) pool module. |
region |
BIG-IP® Global Traffic Manager™ (GTM®) Region module. |
rule |
BIG-IP® Global Traffic Manager (GTM) rule module. |
server |
BIG-IP® Global Traffic Manager™ (GTM®) pool module. |
topology |
BIG-IP® Global Traffic Manager™ (GTM®) Topology Records module. |
wideip |
BIG-IP® Global Traffic Manager™ (GTM®) pool module. |
-
class
f5.bigip.tm.gtm.
Gtm
(tm)[source]¶ Bases:
f5.bigip.resource.OrganizingCollection
BIG-IP® Global Traffic Manager (GTM) organizing collection.
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Call to obtain a list of the reference dicts in the instance items
Returns: List of self.items
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
Submodules¶
datacenter¶
BIG-IP® Global Traffic Manager (GTM) datacenter module.
- REST URI
http://localhost/mgmt/tm/gtm/datacenter
- GUI Path
DNS --> GSLB : Data Centers
- REST Kind
tm:gtm:datacenter:*
-
class
f5.bigip.tm.gtm.datacenter.
Datacenters
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM datacenter collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.datacenter.
Datacenter
(dc_s)[source]¶ Bases:
f5.bigip.resource.Resource
,f5.bigip.mixins.ExclusiveAttributesMixin
BIG-IP® GTM datacenter resource
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
global_settings¶
BIG-IP® Global Traffic Manager™ (GTM®) global-settings submodule.
- REST URI
http://localhost/mgmt/tm/gtm/global-settings
- GUI Path
DNS --> Settings --> GSLB
- REST Kind
tm:gtm:global-settings*
-
class
f5.bigip.tm.gtm.global_settings.
Global_Settings
(gtm)[source]¶ Bases:
f5.bigip.resource.OrganizingCollection
BIG-IP® GTM global-settings organizing collection.
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Call to obtain a list of the reference dicts in the instance items
Returns: List of self.items
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.global_settings.
General
(global_settings)[source]¶ Bases:
f5.bigip.resource.UnnamedResource
BIG-IP® GTM global-settings general resource.
-
create
(**kwargs)¶ Create is not supported for unnamed resources
Raises: UnsupportedMethod
-
delete
(**kwargs)¶ Delete is not supported for unnamed resources
Raises: UnsupportedMethod
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.global_settings.
Load_Balancing
(global_settings)[source]¶ Bases:
f5.bigip.resource.UnnamedResource
BIG-IP® GTM global-settings load balancing resource.
-
create
(**kwargs)¶ Create is not supported for unnamed resources
Raises: UnsupportedMethod
-
delete
(**kwargs)¶ Delete is not supported for unnamed resources
Raises: UnsupportedMethod
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.global_settings.
Metrics
(global_settings)[source]¶ Bases:
f5.bigip.resource.UnnamedResource
BIG-IP® GTM global-settings metrics resource.
-
create
(**kwargs)¶ Create is not supported for unnamed resources
Raises: UnsupportedMethod
-
delete
(**kwargs)¶ Delete is not supported for unnamed resources
Raises: UnsupportedMethod
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
listener¶
BIG-IP® Global Traffic Manager™ (GTM®) Topology Records module.
- REST URI
http://localhost/mgmt/tm/gtm/listener
- GUI Path
DNS --> Delivery : Topology : Records
- REST Kind
tm:gtm:listener:*
-
class
f5.bigip.tm.gtm.listener.
Listeners
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM Listener collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.listener.
Listener
(listeners)[source]¶ Bases:
f5.bigip.resource.Resource
BIG-IP® GTM Listener resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.listener.
Profiles_s
(server)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM Listener Profile sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.listener.
Profile
(profiles)[source]¶ Bases:
f5.bigip.resource.Resource
BIG-IP® GTM Listener Profile sub-collection
Since GTM listener is a wrapper for LTM virtual, profile removal and profile attachment should be done via the created LTM virtual. Only loading or refresh of profiles is supported. Remainder of operations(Create, Update, Modify, Delete) should be done via LTM Virtual Server Profiles endpoint.
-
create
(**kwargs)[source]¶ Create is not supported for profile sub-collection
Raises: UnsupportedOperation
-
modify
(**kwargs)[source]¶ Modify is not supported for profile sub-collection
Raises: UnsupportedOperation
-
update
(**kwargs)[source]¶ Update is not supported for profile sub-collection
Raises: UnsupportedOperation
-
delete
(**kwargs)[source]¶ Delete is not supported for profile sub-collection
Raises: UnsupportedOperation
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
pool¶
BIG-IP® Global Traffic Manager™ (GTM®) pool module.
- REST URI
http://localhost/mgmt/tm/gtm/pool
- GUI Path
DNS --> GSLB : Pools
- REST Kind
tm:gtm:pools:*
-
class
f5.bigip.tm.gtm.pool.
Pools
[source]¶ Bases:
object
BIG-IP® GTM Pool factory
The GTM Pool factory object is used to provide a consistent user experience across the SDK, while supporting the breaking changes in the BIG-IP APIs.
Between the 11.x and 12.x releases of BIG-IP, the REST endpoint for Pool changed from a Collection to an OrganizingCollection. The result is that breaking changes occurred in the API.
This breakage led to a discussion on naming conventions because there appeared to be a conflict now. For example, depending on your version, only one of the following would work.
For 11.x,
tm.gtm.pools.pool.load(name=’foo’)For 12.x,
tm.gtm.pools.a_s.a.load(name=’foo’)but not both. To stick with a consistent user experience, we decided to override the __new__ method to support both examples above. The SDK automatically detects which one to use based on the BIG-IP you are communicating with.
-
class
f5.bigip.tm.gtm.pool.
Members_s
[source]¶ Bases:
object
BIG-IP® GTM Members_s factory
The GTM Members_s factory is used here for code readability and maintenance purposes, to allow us to stay in conventions already set in this SDK, and at the same time accommodate changes between v11 and v12 versions of Members_s sub-collection
-
class
f5.bigip.tm.gtm.pool.
MembersCollection_v11
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v11.x BIG-IP® GTM pool members sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersCollectionA
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® GTM A pool members sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersCollectionAAAA
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® GTM AAAA pool members sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersCollectionCname
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® GTM CNAME pool members sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersCollectionMx
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® GTM MX pool members sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersCollectionNaptr
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® GTM NAPTR pool members sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersCollectionSrv
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® GTM SRV pool members sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Member
[source]¶ Bases:
object
BIG-IP® GTM Members factory
The GTM Members factory is used here for code readability and maintenance purposes, to allow us to stay in conventions already set in this SDK, and at the same time accommodate changes between v11 and v12 versions of Members resource
-
class
f5.bigip.tm.gtm.pool.
MembersResource_v11
(members_s)[source]¶ Bases:
f5.bigip.resource.Resource
v11.x BIG-IP® GTM members resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersResourceA
(members_s)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® GTM A pool members resource
-
create
(**kwargs)[source]¶ This method needs to be created due to a bug in 12.x
The issue arises when you attempt to create a members sub-collection resource and while the operation succeeds BIGIP responds with 404.
By requiring partition as argument we have shielded ourselves from this issue in 12.0.0, however in v12.1.x the problem occurs, even when the partition parameter is submitted. Custom create method is required to catch and deal with iControlUnexpectedHTTPError exception.
Issue is tracked under: ID610441.
- note:: If version is 12.x then we use this method, otherwise we use
- _create method from Resource class as usual.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersResourceAAAA
(members_s)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® GTM AAAA pool members resource
-
create
(**kwargs)[source]¶ This method needs to be created due to a bug in 12.x
The issue arises when you attempt to create a members sub-collection resource and while the operation succeeds BIGIP responds with 404.
By requiring partition as argument we have shielded ourselves from this issue in 12.0.0, however in v12.1.x the problem occurs, even when the partition parameter is submitted. Custom create method is required to catch and deal with iControlUnexpectedHTTPError exception.
Issue is tracked under: ID610441.
- note:: If version is 12.x then we use this method, otherwise we use
- _create method from Resource class as usual.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersResourceCname
(members_s)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® GTM CNAME pool members resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersResourceMx
(members_s)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® GTM MX pool members resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersResourceNaptr
(members_s)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® GTM NAPTR pool members resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
MembersResourceSrv
(members_s)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® GTM SRV pool members resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
PoolCollection
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
v11.x BIG-IP® GTM pool collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Pool
(pool_s)[source]¶ Bases:
f5.bigip.resource.Resource
v11.x BIG-IP® GTM pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
PoolOrganizingCollection
(gtm)[source]¶ Bases:
f5.bigip.resource.OrganizingCollection
v12.x GTM pool is an OC.
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Call to obtain a list of the reference dicts in the instance items
Returns: List of self.items
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
A_s
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® A pool collection.
Class name needed changing due to ‘as’ being reserved python keyword
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
A
(_as)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP®A pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Aaaas
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® AAAA pool collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Aaaa
(aaaas)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® AAAA pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Cnames
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® CNAME pool collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Cname
(cnames)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® CNAME pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Mxs
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® MX pool collection.
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Mx
(mxs)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® MX pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Naptrs
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® NAPTR pool collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Naptr
(naptrs)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® NAPTR pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Srvs
(pool)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® SRV pool collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.pool.
Srv
(naptrs)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® SRV pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
region¶
BIG-IP® Global Traffic Manager™ (GTM®) Region module.
- REST URI
http://localhost/mgmt/tm/gtm/region
- GUI Path
DNS --> GSLB : Topology : Regions
- REST Kind
tm:gtm:region:*
-
class
f5.bigip.tm.gtm.region.
Regions
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM Region collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.region.
Region
(regions)[source]¶ Bases:
f5.bigip.resource.Resource
BIG-IP® GTM Region resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
rule¶
BIG-IP® Global Traffic Manager (GTM) rule module.
- REST URI
http://localhost/mgmt/tm/gtm/rule
- GUI Path
DNS --> GSLB : iRules
- REST Kind
tm:gtm:rule:*
-
class
f5.bigip.tm.gtm.rule.
Rules
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM rule collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.rule.
Rule
(rule_s)[source]¶ Bases:
f5.bigip.resource.Resource
BIG-IP® GTM rule resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
server¶
BIG-IP® Global Traffic Manager™ (GTM®) pool module.
- REST URI
http://localhost/mgmt/tm/gtm/server
- GUI Path
DNS --> GSLB : Servers
- REST Kind
tm:gtm:server:*
-
class
f5.bigip.tm.gtm.server.
Servers
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM server collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.server.
Server
(servers)[source]¶ Bases:
f5.bigip.resource.Resource
BIG-IP® GTM server resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.server.
Virtual_Servers_s
(server)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM virtual server sub-collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.server.
Virtual_Server
(virtual_servers_s)[source]¶ Bases:
f5.bigip.resource.Resource
BIG-IP® GTM virtual server resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
topology¶
BIG-IP® Global Traffic Manager™ (GTM®) Topology Records module.
- REST URI
http://localhost/mgmt/tm/gtm/topology
- GUI Path
DNS --> GSLB : Topology : Records
- REST Kind
tm:gtm:topology:*
-
class
f5.bigip.tm.gtm.topology.
Topology_s
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
BIG-IP® GTM Topology collection
Due to an bug where attempts to create/modify/load/delete etc. of this resource in 12.0.0 Final, we have disabled this resource for version 12.0.0
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.topology.
Topology
(topology_s)[source]¶ Bases:
f5.bigip.resource.Resource
BIG-IP® GTM Topology resource
-
create
(**kwargs)[source]¶ Custom method to implement checking of kwarg[‘name’] contents.
- ::Warning:
- Be sure to format the gtm topology OID string using the following rules:
- Use only a single space between each item in the topology string.
2) Use a fully-pathed name for datacenter, isp, region, and pool objects.
For example: “ldns: subnet 11.11.11.0/24 server: datacenter /Common/DC”
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
wideip¶
BIG-IP® Global Traffic Manager™ (GTM®) pool module.
- REST URI
http://localhost/mgmt/tm/gtm/wideip
- GUI Path
DNS --> GSLB : Wide IPs
- REST Kind
tm:gtm:pools:*
-
class
f5.bigip.tm.gtm.wideip.
Wideips
[source]¶ Bases:
object
BIG-IP® GTM WideIP factory
The GTM WideIP factory object is used to provide a consistent user experience across the SDK, while supporting the breaking changes in the BIG-IP APIs.
Between the 11.x and 12.x releases of BIG-IP, the REST endpoint for WideIP changed from a Collection to an OrganizingCollection. The result is that breaking changes occurred in the API.
This breakage led to a discussion on naming conventions because there appeared to be a conflict now. For example, depending on your version, only one of the following would work.
For 11.x,
tm.gtm.wideips.wideip.load(name=’foo’)For 12.x,
tm.gtm.wideips.a_s.a.load(name=’foo’)but not both. To stick with a consistent user experience, we decided to override the __new__ method to support both examples above. The SDK automatically detects which one to use based on the BIG-IP you are communicating with.
-
class
f5.bigip.tm.gtm.wideip.
WideipOrganizingCollection
(gtm)[source]¶ Bases:
f5.bigip.resource.OrganizingCollection
v12.x GTM WideIP is an OC.
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Call to obtain a list of the reference dicts in the instance items
Returns: List of self.items
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
A_s
(wideip)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® A wideip collection.
Class name needed changing due to ‘as’ being reserved python keyword
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
A
(_as)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP®A wideip resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Aaaas
(wideip)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® AAAA wideip collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Aaaa
(aaaas)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® AAAA wideip resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Cnames
(wideip)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® CNAME wideip collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Cname
(cnames)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® CNAME wideip resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Mxs
(wideip)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® MX wideip collection.
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Mx
(mxs)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® MX wideip resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Naptrs
(wideip)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® NAPTR wideip collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Naptr
(naptrs)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® NAPTR wideip resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Srvs
(wideip)[source]¶ Bases:
f5.bigip.resource.Collection
v12.x BIG-IP® SRV wideip collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Srv
(naptrs)[source]¶ Bases:
f5.bigip.resource.Resource
v12.x BIG-IP® SRV wideip resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
WideipCollection
(gtm)[source]¶ Bases:
f5.bigip.resource.Collection
v11.x BIG-IP® GTM wideip collection
-
create
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
delete
(**kwargs)¶ Implement this by overriding it in a subclass of Resource
Raises: InvalidResource
-
get_collection
(**kwargs)¶ Get an iterator of Python
Resource
objects that represent URIs.The returned objects are Pythonic Resource`s that map to the most recently `refreshed state of uris-resources published by the device. In order to instantiate the correct types, the concrete subclass must populate its registry with acceptable types, based on the kind field returned by the REST server.
Note
This method implies a single REST transaction with the Collection subclass URI.
Raises: UnregisteredKind Returns: list of reference dicts and Python Resource
objects
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
-
class
f5.bigip.tm.gtm.wideip.
Wideip
(wideips)[source]¶ Bases:
f5.bigip.resource.Resource
v11.x BIG-IP® GTM pool resource
-
create
(**kwargs)¶ Create the resource on the BIG-IP®.
Uses HTTP POST to the collection URI to create a resource associated with a new unique URI on the device.
Parameters: kwargs – All the key-values needed to create the resource NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.post method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns:
self
- A python object that represents the object’sconfiguration and state on the BIG-IP®.
-
delete
(**kwargs)¶ Delete the resource on the BIG-IP®.
Uses HTTP DELETE to delete the resource on the BIG-IP®.
After this method is called, and status_code 200 response is received
instance.__dict__
is replace with{'deleted': True}
Parameters: kwargs – The only current use is to pass kwargs to the requests API. If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.delete method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-
exists
(**kwargs)¶ Check for the existence of the named object on the BIG-IP
Sends an HTTP GET to the URI of the named object and if it fails with a :exc:~requests.HTTPError` exception it checks the exception for status code of 404 and returns
False
in that case.If the GET is successful it returns
True
.For any other errors are raised as-is.
Parameters: kwargs – Keyword arguments required to get objects NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: bool – The objects exists on BIG-IP® or not. :raises:
requests.HTTPError
, Any HTTP error that was not statuscode 404.
-
load
(**kwargs)¶ Load an already configured service into this instance.
This method uses HTTP GET to obtain a resource from the BIG-IP®.
Parameters: kwargs – typically contains “name” and “partition” NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.get method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS! :returns: a Resource Instance (with a populated _meta_data[‘uri’])
-
modify
(**patch)¶ Modify the configuration of the resource on device based on patch
-
raw
¶ Display the attributes that the current object has and their values.
Returns: A dictionary of attributes and their values
-
refresh
(**kwargs)¶ Use this to make the device resource be represented by self.
This method makes an HTTP GET query against the device service. This method is run for its side-effects on self. If successful the instance attribute __dict__ is replaced with the dict representing the device state. To figure out what that state is, run a subsequest query of the object like this: As with all CURDLE methods use a “requests_params” dict to pass parameters to requests.session.HTTPMETHOD. See test_requests_params.py for an example. >>> resource_obj.refresh() >>> print(resource_obj.raw)
-
update
(**kwargs)¶ Update the configuration of the resource on the BIG-IP®.
This method uses HTTP PUT alter the resource state on the BIG-IP®.
The attributes of the instance will be packaged as a dictionary. That dictionary will be updated with kwargs. It is then submitted as JSON to the device.
Various edge cases are handled: * read-only attributes that are unchangeable are removed
Parameters: kwargs – keys and associated values to alter on the device NOTE: If kwargs has a ‘requests_params’ key the corresponding dict will be passed to the underlying requests.session.put method where it will be handled according to that API. THIS IS HOW TO PASS QUERY-ARGS!
-