f5.bigip.tm.net

Module contents

BIG-IP® net module

REST URI

http://localhost/mgmt/tm/net/

GUI Path

Network

REST Kind

tm:net:*

Submodule List

arp	BIG-IP® Network ARP module.
dns_resolver	BIG-IP® Network ARP module.
fdb	Directory: net module: fdb.
interface	BIG-IP® Network interface module.
route	BIG-IP® Network route module.
route_domain	Directory: net module: route-domain.
selfip	BIG-IP® Network self-ip module.
trunk	BIG-IP® Network trunk module.
tunnels	BIG-IP® Network tunnels module.
vlan	BIG-IP® Network vlan module.

class f5.bigip.tm.net.Net(tm)

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

arp

BIG-IP® Network ARP module.

REST URI

http://localhost/mgmt/tm/net/arp

GUI Path

Network --> ARP

REST Kind

tm:net:arp:*

class f5.bigip.tm.net.arp.Arps(net)

Bases: f5.bigip.resource.Collection

BIG-IP® network ARP 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.net.arp.Arp(arp_s)

Bases: f5.bigip.resource.Resource

BIG-IP® network ARP 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.

dns_resolver

BIG-IP® Network ARP module.

REST URI

http://localhost/mgmt/tm/net/dns-resolver

GUI Path

Network --> Dns Resolvers

REST Kind

tm:net:dns:*

class f5.bigip.tm.net.dns_resolver.Dns_Resolvers(net)

Bases: f5.bigip.resource.Collection

BIG-IP® network Dns Resolver 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.net.dns_resolver.Dns_Resolver(Dns_Resolvers)

Bases: f5.bigip.resource.Resource

BIG-IP® Dns Resolver 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.

fdb

Directory: net module: fdb.

REST URI

https://localhost/mgmt/tm/net/fdb

GUI Path

XXX

REST Kind

tm:net:fdb:*

class f5.bigip.tm.net.fdb.Fdb(net)

Bases: f5.bigip.resource.OrganizingCollection

BIG-IP® FDB 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.net.fdb.Tunnel(Tunnels)

Bases: f5.bigip.resource.Resource

BIG-IP® Tunnel 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.net.fdb.Tunnels(fdb)

Bases: f5.bigip.resource.Collection

BIG-IP® Tunnels 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.net.fdb.Records_s(tunnel)

Bases: f5.bigip.resource.Collection

BIG-IP® Tunnel records 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.net.fdb.Records(records_s)

Bases: f5.bigip.resource.Resource

BIG-IP® LTM pool members 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.

interface

BIG-IP® Network interface module.

REST URI

http://localhost/mgmt/tm/net/interface

GUI Path

Network --> Interfaces

REST Kind

tm:net:interface:*

class f5.bigip.tm.net.interface.Interfaces(net)

Bases: f5.bigip.resource.Collection

BIG-IP® network interface 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.net.interface.Interface(interface_s)

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

BIG-IP® network interface collection

create(**kwargs)

Create is not supported for interfaces.

Raises:UnsupportedOperation

delete()

Delete is not supported for interfaces.

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.

route

BIG-IP® Network route module.

REST URI

http://localhost/mgmt/tm/net/route

GUI Path

Network --> Routes

REST Kind

tm:net:route:*

class f5.bigip.tm.net.route.Routes(net)

Bases: f5.bigip.resource.Collection

BIG-IP® network 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.net.route.Route(route_s)

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

BIG-IP® network route resource

create(**kwargs)

Create a Route on the BIG-IP® and the associated python object.

One of the following gateways is required when creating the route objects: blackhole, gw, tmInterface, pool.

Params kwargs:keyword arguments passed in from create call Raises:KindTypeMismatch Raises:MissingRequiredCreationParameter Raises:HTTPError Returns:Python Route object

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.

route_domain

Directory: net module: route-domain.

REST URI

https://localhost/mgmt/tm/net/route-domain?ver=11.6.0

GUI Path

XXX

REST Kind

tm:net:route-domain:*

class f5.bigip.tm.net.route_domain.Route_Domains(net)

Bases: f5.bigip.resource.Collection

BIG-IP® Route Domain 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.net.route_domain.Route_Domain(Route_Domains)

Bases: f5.bigip.resource.Resource

BIG-IP® Route Domain collection.

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.

selfip

BIG-IP® Network self-ip module.

Note

Self IPs path does not match their kind or URI because the string self causes problems in Python because it is a reserved word.

REST URI

http://localhost/mgmt/tm/net/self

GUI Path

Network --> Self IPs

REST Kind

tm:net:self:*

class f5.bigip.tm.net.selfip.Selfips(net)

Bases: f5.bigip.resource.Collection

BIG-IP® network Self-IP collection

Note

The objects in the collection are actually called ‘self’ in iControlREST, but obviously this will cause problems in Python so we changed its name to Selfip.

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.net.selfip.Selfip(selfip_s)

Bases: f5.bigip.resource.Resource

BIG-IP® Self-IP resource

Use this object to create, refresh, update, delete, and load self ip configuration on the BIG-IP®. This requires that a VLAN object be present on the system and that object’s :attrib:`fullPath` be used as the VLAN name.

The address that is used for create is a <ipaddress>/<netmask>. For example 192.168.1.1/32.

Note

The object is actually called self in iControlREST, but obviously this will cause problems in Python so we changed its name to Selfip.

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.

trunk

BIG-IP® Network trunk module.

REST URI

http://localhost/mgmt/tm/net/trunk

GUI Path

Network --> Trunks

REST Kind

tm:net:trunk:*

class f5.bigip.tm.net.trunk.Trunks(net)

Bases: f5.bigip.resource.Collection

BIG-IP® network 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.net.trunk.Trunk(trunks)

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

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.

tunnels

BIG-IP® Network tunnels module.

REST URI

http://localhost/mgmt/tm/net/tunnels

GUI Path

Network --> tunnels

REST Kind

tm:net:tunnels:*

class f5.bigip.tm.net.tunnels.TunnelS(net)

Bases: f5.bigip.resource.OrganizingCollection

BIG-IP® network tunnels 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.net.tunnels.Tunnels(tunnelS)

Bases: f5.bigip.resource.Collection

BIG-IP® network tunnels resource (collection for GRE, Tunnel, VXLANs

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.net.tunnels.Tunnel(tunnels)

Bases: f5.bigip.resource.Resource

BIG-IP® tunnels tunnel 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.net.tunnels.Gres(tunnels)

Bases: f5.bigip.resource.Collection

BIG-IP® tunnels GRE 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.net.tunnels.Gre(gres)

Bases: f5.bigip.resource.Resource

BIG-IP® tunnels GRE 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.net.tunnels.Vxlans(tunnels)

Bases: f5.bigip.resource.Collection

BIG-IP® tunnels VXLAN 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.net.tunnels.Vxlan(vxlans)

Bases: f5.bigip.resource.Resource

BIG-IP® tunnels VXLAN 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.

vlan

BIG-IP® Network vlan module.

REST URI

http://localhost/mgmt/tm/net/vlan

GUI Path

Network --> Vlans

REST Kind

tm:net:vlan:*

class f5.bigip.tm.net.vlan.Vlans(net)

Bases: f5.bigip.resource.Collection

BIG-IP® network Vlan 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.net.vlan.Vlan(vlan_s)

Bases: f5.bigip.resource.Resource

BIG-IP® network Vlan 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.net.vlan.Interfaces_s(vlan)

Bases: f5.bigip.resource.Collection

BIG-IP® network Vlan interface collection.

Note

Not to be confused with tm/mgmt/net/interface. This is object is actually called interfaces with an s by the BIG-IP’s REST API.

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.net.vlan.Interfaces(interfaces_s)

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

BIG-IP® network Vlan interface 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.

As tagMode parameter will be required only if tagged is set to ‘True’ we have to use conditional to capture this logic during create.

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.

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)