f5.bigip.tm.sys

Module contents

BIG-IP® System (sys) module

REST URI
http://localhost/mgmt/tm/sys/
GUI Path
System
REST Kind
tm:sys:*

Submodule List

application BIG-IP® iApp (application) module
config BIG-IP® system config module
crypto BIG-IP® system config module
daemon_log_settings BIG-IP® system daemon log settings module
db BIG-IP® db module
dns BIG-IP® system dns module
failover BIG-IP® system failover module
file BIG-IP® system file module
folder BIG-IP® system folder module
global_settings BIG-IP® system global-settings module
httpd BIG-IP® system dns module
icall BIG-IP® system icall module
management_ip BIG-IP® system management IP module
management_route BIG-IP® system management route module
ntp BIG-IP® system ntp module
performance BIG-IP® system peformance stats module.
provision BIG-IP® system file module
sflow BIG-IP® system sflow module
smtp_server BIG-IP® SMTP Server module
snmp BIG-IP® SNMP submodule.
sshd BIG-IP® system sshd module
syslog BIG-IP® system syslog module
ucs BIG-IP® system config module
class f5.bigip.tm.sys.Sys(tm)[source]

Bases: f5.bigip.resource.OrganizingCollection

BIG-IP® System (sys) organizing collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

Subpackages

BIG-IP® System Software module

REST URI
http://localhost/mgmt/tm/sys/software
GUI Path
System
REST Kind
tm:sys:software:*
class f5.bigip.tm.sys.software.Software(tm)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

Submodules

application

BIG-IP® iApp (application) module

REST URI
http://localhost/mgmt/sys/application/
GUI Path
iApps
REST Kind
tm:sys:application:*
class f5.bigip.tm.sys.application.Application(sys)[source]

Bases: f5.bigip.resource.OrganizingCollection

BIG-IP® iApp collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.application.Aplscripts(application)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® iApp script collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.application.Aplscript(apl_script_s)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® iApp script 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.application.Customstats(application)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® iApp custom stats sub-collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.application.Customstat(custom_stat_s)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® iApp custom stats sub-collection 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.application.Services(application)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® iApp service sub-collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.application.Service(service_s)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® iApp service sub-collection resource

update(**kwargs)[source]

Push local updates to the object on the device.

Params kwargs:keyword arguments for accessing/modifying the object
Returns:updated Python object
exists(**kwargs)[source]

Check for the existence of the named object on the BIG-IP

Override of resource.Resource exists() to build proper URI unique to service resources.

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 status

code 404.
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

class f5.bigip.tm.sys.application.Templates(application)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® iApp template sub-collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.application.Template(template_s)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® iApp template sub-collection 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

config

BIG-IP® system config module

REST URI
http://localhost/mgmt/tm/sys/config
GUI Path
N/A
REST Kind
tm:sys:config:*
class f5.bigip.tm.sys.config.Config(sys)[source]

Bases: f5.bigip.resource.UnnamedResource, f5.bigip.mixins.CommandExecutionMixin

update(**kwargs)[source]

Update is not supported for Config

Raises:UnsupportedOperation
exec_cmd(command, **kwargs)[source]

Normal save and load only need the command.

To merge, just supply the merge and file arguments as kwargs like so: exec_cmd(‘load’, merge=True, file=’/path/to/file.txt’)

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
load(**kwargs)

Load is not supported for command execution

Raises:UnsupportedOperation
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)

crypto

BIG-IP® system config module

REST URI
http://localhost/mgmt/tm/sys/config
GUI Path
N/A
REST Kind
tm:sys:config:*
class f5.bigip.tm.sys.crypto.Crypto(sys)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.crypto.Keys(crypto)[source]

Bases: f5.bigip.resource.Collection, f5.bigip.mixins.CommandExecutionMixin

BIG-IP® Crypto key collection

note:: This collection supports install command. Given the fact that we will be expecting hyphen parameters, the function will need to utilize variable keyword argument syntax. In other words define a dictionary with the arbitrary keys and then pass it as in the form **foo into the method call. e.g.

param_set ={‘from-local-file’: FOOPATH, ‘name’: ‘FOOKEY’} bigip.tm.sys.crypto.keys.exec_cmd(‘install’, **param_set)

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

exec_cmd(command, **kwargs)

Wrapper method that can be changed in the inheriting classes.

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
load(**kwargs)

Load is not supported for command execution

Raises:UnsupportedOperation
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.crypto.Key(keys)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® Crypto key 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.crypto.Certs(crypto)[source]

Bases: f5.bigip.resource.Collection, f5.bigip.mixins.CommandExecutionMixin

BIG-IP® Crypto cert collection

note:: This collection supports install command. Given the fact that we will be expecting hyphen parameters, the function will need to utilize variable keyword argument syntax. In other words define a dictionary with the arbitrary keys and then pass it as in the form **foo into the method call. e.g.

param_set ={‘from-local-file’: FOOPATH, ‘name’: ‘FOOCERT’} bigip.tm.sys.crypto.certs.exec_cmd(‘install’, **param_set)

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

exec_cmd(command, **kwargs)

Wrapper method that can be changed in the inheriting classes.

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
load(**kwargs)

Load is not supported for command execution

Raises:UnsupportedOperation
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.crypto.Cert(certs)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® Crypto cert 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

daemon_log_settings

BIG-IP® system daemon log settings module

REST URI
http://localhost/mgmt/tm/sys/daemon-log-settings
tmsh Path
sys --> daemon-log-settings --> all-properties
GUI Path
system --> logs --> configuration --> options
REST Kind
tm:sys:daemon-log-settings:*
class f5.bigip.tm.sys.daemon_log_settings.Daemon_Log_Settings(sys)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.daemon_log_settings.Clusterd(daemon_log_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system daemon log settings clusterd resource

The object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.daemon_log_settings.Csyncd(daemon_log_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system daemon log settings csyncd resource

The object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.daemon_log_settings.Icrd(daemon_log_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system daemon log settings icrd resource

The object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.daemon_log_settings.Lind(daemon_log_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system daemon log settings lind resource

The object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.daemon_log_settings.Mcpd(daemon_log_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system daemon log settings mcpd resource

The object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.daemon_log_settings.Tmm(daemon_log_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system daemon log settings clusterd resource

The object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

db

BIG-IP® db module

REST URI
http://localhost/mgmt/sys/db/
GUI Path
N/A
REST Kind
tm:sys:db:*
class f5.bigip.tm.sys.db.Dbs(sys)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® db collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.db.Db(dbs)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® db resource

Note

db objects are read-only.

create(**kwargs)[source]

Create is not supported for db resources.

Raises:UnsupportedOperation
delete(**kwargs)[source]

Delete is not supported for db resources.

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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

dns

BIG-IP® system dns module

REST URI
http://localhost/mgmt/tm/sys/dns
GUI Path
System --> Configuration --> Device --> DNS
REST Kind
tm:sys:dns:*
class f5.bigip.tm.sys.dns.Dns(sys)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system DNS unnamed resource

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

failover

BIG-IP® system failover module

REST URI
http://localhost/mgmt/tm/sys/failover
GUI Path
System --> Failover
REST Kind
tm:sys:failover:*
class f5.bigip.tm.sys.failover.Failover(sys)[source]

Bases: f5.bigip.resource.UnnamedResource, f5.bigip.mixins.CommandExecutionMixin

BIG-IP® Failover stats and state change.

The failover object only supports load, update, and refresh because it is
an unnamed resource.

To force the unit to standby call the update() method as follows:

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

update(**kwargs)[source]

Update is not supported for Failover

Raises:UnsupportedOperation
exec_cmd(command, **kwargs)[source]

Defining custom method to append ‘exclusive_attributes’.

WARNING: Some parameters are hyphenated therefore the function

will need to utilize variable keyword argument syntax. This only applies when utilCmdArgs method is not in use.

eg.

param_set ={‘standby’:True ‘traffic-group’: ‘traffic-group-1’} bigip.tm.sys.failover.exec_cmd(‘run’, **param_set

The ‘standby’ attribute cannot be present with either ‘offline’ or ‘online’ attribute, whichever is present. Additionally we check for existence of same attribute values in ‘offline’ and ‘online’ if both present.

note:: There is also another way of using failover endpoint,

by the means of ‘utilCmdArgs’ attribute, here the syntax will resemble more that of the ‘tmsh run sys failover…’ command.

eg. exec_cmd(‘run’, utilCmdArgs=’standby traffic-group traffic-group-1’)

:: raises InvalidParameterValue

toggle_standby(**kwargs)[source]

Toggle the standby status of a traffic group.

WARNING: This method which used POST obtains json keys from the device that are not available in the response to a GET against the same URI.

NOTE: This method method is deprecated and probably will be removed,
usage of exec_cmd is encouraged.
create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
load(**kwargs)

Load is not supported for command execution

Raises:UnsupportedOperation
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)

file

BIG-IP® system file module

REST URI
http://localhost/mgmt/tm/sys/file
GUI Path
N/A
REST Kind
tm:sys:file:*
class f5.bigip.tm.sys.file.File(sys)[source]

Bases: f5.bigip.resource.OrganizingCollection

BIG-IP® System sys file collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Data_Groups(File)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® System sys file data-groups collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Data_Group(data_groups)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® System sys file data-groups resource.

update(**kwargs)[source]

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

class f5.bigip.tm.sys.file.Ifiles(File)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® System sys file iFiles collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ifile(ifiles)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® System sys file iFiles resource.

modify(**kwargs)[source]

Modify is not supported for iFiles

Raises:UnsupportedOperation
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Certs(File)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® System sys file ssl-certs collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Cert(ssl_certs)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® System sys file ssl-certs resource.

modify(**kwargs)[source]

Modify is not supported for iFiles

Raises:UnsupportedOperation
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Crls(File)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® System sys file ssl-crls collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Crl(ssl_crls)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® System sys file ssl-crls resource.

modify(**kwargs)[source]

Modify is not supported for iFiles

Raises:UnsupportedOperation
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Csrs(File)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® System sys file ssl-csrs collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Csr(ssl_csrs)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® System sys file ssl-csrs resource.

modify(**kwargs)[source]

Modify is not supported for iFiles

Raises:UnsupportedOperation
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Keys(File)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® System sys file ssl-keys collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.file.Ssl_Key(ssl_keys)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® System sys file ssl-keys resource.

modify(**kwargs)[source]

Modify is not supported for iFiles

Raises:UnsupportedOperation
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

folder

BIG-IP® system folder module

REST URI
http://localhost/mgmt/tm/sys/folder
REST Kind
tm:sys:folder:*
class f5.bigip.tm.sys.folder.Folders(sys)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® system folder collection.

These are what we refer to as partition in the SDK.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.folder.Folder(folder_s)[source]

Bases: f5.bigip.resource.Resource

update(**kwargs)[source]

Update the object, removing device group if inherited

If inheritedDevicegroup is the string “true” we need to remove deviceGroup from the args before we update or we get the following error:

The floating traffic-group: /Common/traffic-group-1 can only be set on /testfolder if its device-group is inherited from the root folder

exists(**kwargs)[source]

Check for the existence of the named object on the BIG-IP

Tries to load() the object and if it fails checks the exception for 404. If the load() is successful it returns True if the exception is requests.HTTPError and the status_code is 404 it will return error. All 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 status

code 404.
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

global_settings

BIG-IP® system global-settings module

REST URI
http://localhost/mgmt/tm/sys/global-settings
GUI Path
System --> Configuration --> Device
REST Kind
tm:sys:global-settings:*
class f5.bigip.tm.sys.global_settings.Global_Settings(sys)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system global-settings resource

The global_settings object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

httpd

BIG-IP® system dns module

REST URI
http://localhost/mgmt/tm/sys/dns
tmsh Path
sys --> httpd --> all-properties
GUI Path
various
REST Kind
tm:sys:httpd:*
class f5.bigip.tm.sys.httpd.Httpd(sys)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system HTTPD unnamed resource

This is an unnamed resource so it has no ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

icall

BIG-IP® system icall module

REST URI
http://localhost/mgmt/tm/sys/icall
GUI Path
N/A
REST Kind
tm:sys:icall:*
class f5.bigip.tm.sys.icall.Icall(sys)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Handler(Icall)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Periodics(Handler)[source]

Bases: f5.bigip.resource.Collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Periodic(Periodics)[source]

Bases: f5.bigip.resource.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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Perpetuals(Handler)[source]

Bases: f5.bigip.resource.Collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Perpetual(Perpetuals)[source]

Bases: f5.bigip.resource.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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Triggered_s(Handler)[source]

Bases: f5.bigip.resource.Collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Triggered(Triggered_s)[source]

Bases: f5.bigip.resource.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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Scripts(Icall)[source]

Bases: f5.bigip.resource.Collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Script(Scripts)[source]

Bases: f5.bigip.resource.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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Istats_Triggers(Icall)[source]

Bases: f5.bigip.resource.Collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.icall.Istats_Trigger(Istats_Triggers)[source]

Bases: f5.bigip.resource.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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

management_ip

BIG-IP® system management IP module

REST URI
http://localhost/mgmt/tm/sys/management-ip
GUI Path
System --> Platform
REST Kind
tm:sys:management-ip:*
class f5.bigip.tm.sys.management_ip.Management_Ips(sys)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® management-ip collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.management_ip.Management_Ip(Management_Ips)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® management-ip resource

load(**kwargs)[source]

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: A Resource Instance with a populated _meta_data['uri']
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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 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
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

management_route

BIG-IP® system management route module

REST URI
http://localhost/mgmt/tm/sys/management-route
GUI Path
System --> Platform
REST Kind
tm:sys:management-route:management-routestate
class f5.bigip.tm.sys.management_route.Management_Routes(sys)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® management-route collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.management_route.Management_Route(Management_Routes)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® system management-route resource

update(**kwargs)[source]

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

modify(**kwargs)[source]

Modify the configuration of the resource on device based on patch

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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

ntp

BIG-IP® system ntp module

REST URI
http://localhost/mgmt/tm/sys/ntp
GUI Path
System --> Configuration --> Device --> NTP
REST Kind
tm:sys:ntp:*
class f5.bigip.tm.sys.ntp.Ntp(sys)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system NTP unnamed resource

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.ntp.Restricts(ntp)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® system NTP restrict sub-collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.ntp.Restrict(restricts)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® system NTP restrict sub-collection 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

performance

BIG-IP® system peformance stats module.

REST URI
http://localhost/mgmt/tm/sys/performance
GUI Path
System --> Users --> Partition List
REST Kind
tm:sys:performance:*
class f5.bigip.tm.sys.performance.Performances(sys)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® system performace stats collection

get_collection()[source]

Performance collections are not proper BIG-IP® collection objects.

Raises:UnsupportedOperation
create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.performance.All_Stats(performance)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system performace stats unnamed resource

update(**kwargs)[source]

Update is not supported for statistics.

Raises:UnsupportedOperation
create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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)

provision

BIG-IP® system file module

REST URI
http://localhost/mgmt/tm/sys/provision
GUI Path
N/A
REST Kind
tm:sys:provision:*
class f5.bigip.tm.sys.provision.Provision(sys)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Afm(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision afm resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Am(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision afm resource

The am object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Apm(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision apm resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Asm(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision asm resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Avr(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision avr resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Dos(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision dos resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Fps(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision fps resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Gtm(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision gtm resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Ili(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision ili resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Ilx(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision ilx resource

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Lc(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision lc resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Ltm(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision ltm resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Pem(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision pem resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Swg(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision swg resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Urldb(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision urldb resource

The afm object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.provision.Vcmp(provision)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system provision vcmp resource

The vcmp object only supports load and update because it is an unnamed resource.

Note

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

sflow

BIG-IP® system sflow module

REST URI
http://localhost/mgmt/tm/sys/sflow
GUI Path
System->sFlow
REST Kind
tm:sys:sflow:*
class f5.bigip.tm.sys.sflow.Sflow(sys)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.sflow.Global_Settings(sflow)[source]

Bases: f5.bigip.resource.OrganizingCollection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
get_collection(**kwargs)

Call to obtain a list of the reference dicts in the instance items

Returns:
list: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.sflow.Http(global_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.sflow.Interface(global_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.sflow.System(global_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.sflow.Vlan(global_settings)[source]

Bases: f5.bigip.resource.UnnamedResource

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.sflow.Receivers(sflow)[source]

Bases: f5.bigip.resource.Collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.sflow.Receiver(receivers)[source]

Bases: f5.bigip.resource.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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

smtp_server

BIG-IP® SMTP Server module

REST URI
http://localhost/mgmt/sys/smtp-server/
GUI Path
Systems > Configuration > Device > SMTP
REST Kind
tm:sys:smtp-server:*
class f5.bigip.tm.sys.smtp_server.Smtp_Servers(sys)[source]

Bases: f5.bigip.resource.Collection

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.smtp_server.Smtp_Server(smtp_servers)[source]

Bases: f5.bigip.resource.Resource, f5.bigip.mixins.ExclusiveAttributesMixin

create(**kwargs)[source]

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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
and state on the BIG-IP®.
load(**kwargs)[source]

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: A Resource Instance with a populated _meta_data['uri']
refresh(**kwargs)[source]

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)[source]

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 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

snmp

BIG-IP® SNMP submodule.

REST URI
http://localhost/mgmt/tm/sys/snmp/
GUI Path
System --> SNMP
REST Kind
tm:snmp:*
class f5.bigip.tm.sys.snmp.Snmp(sys)[source]

Bases: f5.bigip.resource.UnnamedResource

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.snmp.Communities_s(snmp)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® SNMP Communities collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.snmp.Community(communities_s)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® SNMP Community 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.snmp.Traps_s(snmp)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® SNMP Traps collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.snmp.Trap(traps_s)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® SNMP Trap resource.

update(**kwargs)[source]

Due to a password decryption bug

we will disable update() method for 12.1.0 and up

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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

class f5.bigip.tm.sys.snmp.Users_s(snmp)[source]

Bases: f5.bigip.resource.Collection

BIG-IP® SNMP Users collection.

create(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete(**kwargs)

Implement this by overriding it in a subclass of Resource

Raises:
InvalidResource: If method is used.
delete_collection(**kwargs)

One can not simply delete a collection.

This is to support odata usage via the options request parameter:

requests_params={'params': 'options=glob_pattern'}

where glob_pattern can be used to delete one or all of a particular collection. Not submitting the requests params will fail, and specifying patterns that match default resources will fail as well.

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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

class f5.bigip.tm.sys.snmp.User(users_s)[source]

Bases: f5.bigip.resource.Resource

BIG-IP® SNMP User resource.

update(**kwargs)[source]

Due to a password decryption bug

we will disable update() method for 12.1.0 and up

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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

All the key-values needed to create the resource.

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.

Returns:
Resource: A python object that represents the object’s configuration
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}

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above 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.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args.

Returns:
bool: True is the object exists. False otherwise.
Raises:
requests.HTTPError: Any HTTP error that was not status code 404.
load(**kwargs)

Load an already configured service into this instance.

This method uses HTTP GET to obtain a resource from the BIG-IP®.

The URI of the target service is constructed from the instance’s container and **kwargs.

kwargs typically requires the keys name and partition. this may, or may not, be true for a specific service.

Args:
**kwargs (dict): Arbitrary number of keyword arguments.

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.

Use the method above to pass query args

Returns:
Resource: 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)

sshd

BIG-IP® system sshd module

REST URI
http://localhost/mgmt/tm/sys/sshd
GUI Path
System --> Configuration --> Device --> SSHD
REST Kind
tm:sys:sshd:sshdstate
class f5.bigip.tm.sys.sshd.Sshd(sys)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system SSHD unnamed resource

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

syslog

BIG-IP® system syslog module

REST URI
http://localhost/mgmt/tm/sys/syslog
GUI Path
System --> Logs --> Configuration --> Remote Logging
REST Kind
tm:sys:sshd:sshdstate
class f5.bigip.tm.sys.syslog.Syslog(sys)[source]

Bases: f5.bigip.resource.UnnamedResource

BIG-IP® system syslog unnamed resource

This is an unnamed resource so it has not ~Partition~Name pattern at the end of its URI.

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.

ucs

BIG-IP® system config module

REST URI
``http://localhost/mgmt/tm/sys/ucs`
GUI Path
N/A
REST Kind
tm:sys:ucs:*
class f5.bigip.tm.sys.ucs.Ucs(sys)[source]

Bases: f5.bigip.resource.UnnamedResource, f5.bigip.mixins.CommandExecutionMixin

BIG-IP® system UCS resource

Given the fact that 11.6.0 UCS via rest is broken, this feature will be supported in 12.0.0 and above. Listing of installed UCS has been fixed in 12.1.0. This resource is a collection which does not allow listing of each ucs as a resource. ‘Items’ attribute of the loaded object is used to access the list of installed UCS files.

Caveat: Loading UCS will result in ICRD restarting, therefore due to ID476518 502 Bad Gateway is generated, this is working as intended, at least until some architecture changes have been made.

exec_cmd(command, **kwargs)[source]

Due to ID476518 the load command need special treatment.

load(**kwargs)[source]

Method to list the UCS on the system

Since this is only fixed in 12.1.0 and up we implemented version check here

create(**kwargs)

Create is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
delete(**kwargs)

Delete is not supported for unnamed resources

Raises:
UnsupportedMethod: If the method is used
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

Args:
kwargs (dict): Arbitrary number of keyword arguments.

Keys and associated values to alter on the device.

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.