def __init__(self,
dnac,
device_id,
verify=False,
timeout=5):
"""
Creates a new DeviceArchive object and sets the target network device's ID.
:param dnac: Reference to the program's Dnac object.
type: Dnac object
required: yes
default: None
:param device_id: The UUID in Cisco DNAC for the device to be managed.
type: str
required: yes
default: None
:param verify: Flag indicating whether or not to validate Cisco DNA Center's certificate.
type: bool
required: no
default: False
:param timeout: Number of seconds to wait for Cisco DNA Center to respond to an API call.
type: int
required: no
default: 5
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = DEVICE_ARCHIVE_RESOURCE_PATH[dnac.version]
else:
raise DnacError('%s: __init__: %s: %s' % (MODULE, UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__device = device_id
self.__versions = [] # list of Version objects that contain the config files
super(DeviceArchive, self).__init__(dnac,
'%s_archive' % self.__device,
resource=path,
verify=verify,
timeout=timeout)
def __init__(self, dnac, deployment_id, verify=False, timeout=5):
"""
Creates a deployment object and sets the deployment job's UUID.
:param dnac: A reference to the master Dnac instance.
type: Dnac object
required: yes
default: None
:param deployment_id: The deployment job's UUID.
type: str
required: yes
default: None
:param verify: A flag that sets whether or not Cisco DNA Center's certificated should be authenticated.
type: bool
required: no
default: False
:param timeout: The number of seconds to wait for a response from Cisco DNAC.
type: int
required: no
default: 5
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = DEPLOYMENT_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__deployment = {}
self.__deployment_id = deployment_id
super(Deployment, self).__init__(dnac,
('deployment_%s' % deployment_id),
resource=path,
verify=verify,
timeout=timeout)
def __init__(self, dnac, name, verify=False, timeout=5):
"""
ConfigArchive's __init__ method initializes the object with an empty archive.
:param dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: yes
:param name: A user friendly name for finding this object in a Dnac instance.
type: str
default: none
required: yes
:param verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
:param timeout: The number of seconds to wait for Cisco DNAC's response.
type: int
default: 5
required: no
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = ARCHIVE_RESOURCE_PATH[dnac.version]
else:
raise DnacError('%s: __init__: %s: %s' %
(MODULE, UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__archive = {} # key = deviceId, value = DeviceArchive
super(ConfigArchive, self).__init__(dnac,
'%s_archive' % name,
resource=path,
verify=verify,
timeout=timeout)
def get_device_detail_by_mac(self, mac):
"""
get_device_detail_by_mac searches for a devices using its MAC address and returns a detailed listing of its
current configuration state and health.
:param mac: The network device's MAC address.
type: str
default: none
required: yes
:return: dict
"""
if not self.__detail_resource:
raise DnacError('get_device_detail_by_mac: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, self.dnac.version))
time = TimeStamp()
query = '?timestamp=%s&searchBy=%s&identifier=%s' % \
(time, mac, DEVICE_DETAIL_IDENTIFIERS['mac'])
url = self.dnac.url + self.__detail_resource + query
detail, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_device_detail_by_mac',
REQUEST_NOT_OK, url, OK, status,
ERROR_MSGS[status], str(detail))
self.__device_detail = detail['response']
return self.__device_detail
def __init__(self,
dnac,
name=SITE_HIERARCHY_NAME,
verify=False,
timeout=5):
"""
Creates at new Site object.
:param dnac: The Cisco DNA Center cluster to which the site belongs.
type: Dnac object
required: yes
default: none
:param name: The site hierarchy's name.
type: str
required: no
default: Either the Dnac object's name or IP address concatenated with SITE_HIERARCHY_NAME.
:param verify: A flag indicating whether or not to validate the cluster's certificate.
type: bool
required: no
default: False
:param timeout: The number of seconds to wait for a response from a site hierarchy API call.
type: int
required: no
default: 5
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = SITE_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
if dnac.name != NO_DNAC_PATH:
site_hierarchy_name = '%s%s' % (dnac.name, name)
elif dnac.ip != NO_DNAC_PATH:
site_hierarchy_name = '%s%s' % (dnac.ip, name)
else:
raise DnacError('__init__: critical error: %s: %s' %
(NO_DNAC_PATH_ERROR, NO_DNAC_PATH_RESOLUTION))
super(SiteHierarchy, self).__init__(dnac,
site_hierarchy_name,
resource=path,
verify=verify,
timeout=timeout)
self.__all_sites = []
self.__site_nodes = multi_key_dict()
self.__site_count = NO_SITES
self.load_sites()
def __init__(self, dnac, name, cmds=None, verify=False, timeout=5):
"""
The __init__ method creates a CommandRunner object. As with all
classes that inherit from DnacApi, a minimum of a Dnac container
and a name must be given. Optionally, a dictionary of the CLI
commands to run and the UUIDs of devices to run them on may
be specified.
Parameters:
dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: yes
name: A user friendly name for finding this object in a Dnac
instance.
type: str
default: none
required: yes
cmds: A dict with the commands and target devices.
type: dict
default: none
required: no
verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
timeout: The number of seconds to wait for Cisco DNAC's
response.
type: int
default: 5
required: no
Return Values:
CommandRunner object: The newly constructed CommandRunner
Usage:
d = Dnac()
cmds = {'commands': ['show version', 'show module'],
'deviceUuids': ['<switch>', '<router>]}
cmd = CommandRunner(d, "aName", cmds=cmds)
"""
# check Cisco DNA Center's version and set the resourece path
if cmds is None:
cmds = {}
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = COMMANDRUNNER_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
# setup the attributes
self.__cmds = cmds # commands to run
self.__task = None # Task object created after running cmds
super(CommandRunner, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
def __init__(self,
dnac,
name,
verify=False,
timeout=5):
"""
The __init__ class method instantiates a new NetworkDevice object.
Be certain that a Dnac object is first created, then pass that
object and a user-friendly name for the NetworkDevice instance
that can be used to access it in the Dnac.api dictionary.
Parameters:
dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: Yes
name: A user friendly name for find this object in a Dnac
instance.
type: str
default: none
required: yes
verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
timeout: The number of seconds to wait for Cisco DNAC's
response.
type: int
default: 5
required: no
Return Values:
NetworkDevice object: a new NetworkDevice object.
Usage:
d = Dnac()
nd = NetworkDevice(d, 'network-device')
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = NETWORK_DEVICE_RESOURCE_PATH[dnac.version]
else:
raise DnacError(
'__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version)
)
if dnac.version in DEVICE_DETAIL_RESOURCE_PATH:
self.__detail_resource = DEVICE_DETAIL_RESOURCE_PATH[dnac.version]
else:
self.__detail_resource = None
self.__devices = None # API returns list or dict based on the call
self.__vlans = []
self.__device_detail = {}
super(NetworkDevice, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
def __init__(self, dnac, name, verify=False, timeout=5):
"""
Template's __init__ method constructs a new Template object. It automatically searches for the template in
Cisco DNA Center by the Template's name. If found, it will load the parent template information and all
committed versions. This class' attributes are decorator functions that directly access the template's info,
the parent template, and all available versions.
:param dnac: A reference to the master Dnac instance.
type: Dnac object
required: yes
default: None
:param name: The template's name as listed in Cisco DNA Center.
type: str
required: yes
default: None
:param verify: A flag that sets whether or not Cisco DNA Center's certificated should be authenticated.
type: bool
required: no
default: False
:param timeout: The number of seconds to wait for a response from Cisco DNAC.
type: int
required: no
default: 5
"""
# check Cisco DNA Center's version and set the resource path
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = TEMPLATE_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
# template attributes
self.__template = {
} # contents of the template info found by querying all available templates
self.__versions = {
} # contents of the template's parent (index=0) and versionsInfo keyed by version number
# deployment attributes
self.__params = {
} # parameters and their values to apply during deployment
self.__target_id = '' # where to deploy the latest committed template
self.__target_type = TARGET_BY_DEFAULT # how to find the target
self.__deployment = '' # object for monitoring the deployment
# DnacApi attributes
super(Template, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
# load the template
if self.name != STUB_TEMPLATE:
self.load_template(self.name)
def __init__(self, dnac, id, verify=False, timeout=5):
"""
__init__ makes a new Task object. An empty task object may be
created by only passing a Dnac object and the task's UUID.
The Task instance sets its name as "task_<id>" and the URL for
querying the task's progress.
Parameters:
dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: yes
id: The UUID of the task running on Cisco DNAC. The new object
sets its name and url based on id's value:
name = "task_<id>"
url = "dnac.url/self.resource/<id>"
type: str
default: none
required: yes
verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
timeout: The number of seconds to wait for Cisco DNAC's response.
type: int
default: 5
required: no
Return Values:
Task object: a new Task object.
Usage:
d = Dnac()
id = <task ID from Cisco DNAC>
task = Task(d, a_task_id)
task.check_task()
"""
# check Cisco DNA Center's version and set the resource path
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = TASK_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
# setup the attributes
self.__id = id
self.__progress = TASK_EMPTY
self.__file = None
self.__file_id = ''
super(Task, self).__init__(dnac, ('task_%s' % self.__id),
resource=path,
verify=verify,
timeout=timeout)
def __init__(self, dnac, id, verify=False, timeout=5):
"""
Class method __init__ creates a new File instance. When
making a File object, pass it a Dnac object and the UUID
of the file in Cisco DNAC that this object represents.
Parameters:
dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: yes
id: The UUID of the file in Cisco DNAC this object represents.
If included as part of calling __init__, the new object sets
its name and url based on id's value:
name = 'task_<id>'
url = 'dnac.url/self.respath/<id>'
type: str
default: none
required: yes
verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
timeout: The number of seconds to wait for Cisco DNAC's
response.
type: int
default: 5
required: no
Return Values:
File object: a new File instance.
Usage:
d = Dnac()
id = '<file UUID>'
results = File(d, id)
"""
# check Cisco DNA Center's version and set the resource path
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = FILE_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
# setup the attributes
self.__id = id # use the fileId in the task's progress
self.__results = [] # raw data in case further processing needed
super(File, self).__init__(dnac, ('file_%s' % self.__id),
resource=path,
verify=verify,
timeout=timeout)
def __init__(self,
dnac,
name,
verify=False,
timeout=5):
"""
Upon creating a new Project object, __init__ sets the __project field as an empty dict. As long as the
project's name is not set to 'NEW_PROJECT', the Project attempts to load its attributes as given in Cisco
DNA Center. If its name is NEW_PROJECT, then this method creates an empty Project that can be used to
import a project from a backup file (see the import_project method for more details).
Usage:
d = Dnac()
proj = Project(d, 'aProject')
:param dnac: a reference to the containing Dnac object
type: Dnac object
default: none
required: yes
:param name: the project's name as it appears in a live Cisco DNA Center cluster
type: str
default: none
required: yes
:param verify: a flag used to check DNAC's certificate
type: bool
default: False
required: no
:param timeout: the time in seconds to wait for an API response from DNA Center
type: int
default: 5
required: no
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = PROJECT_RESOURCE_PATH[dnac.version]
else:
raise DnacError('%s: __init__: %s: %s' % (MODULE, UNSUPPORTED_DNAC_VERSION, dnac.version))
# initialize attributes
self.__project = {}
# setup the parent class
super(Project, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
# retrieve the project
if self.name != STUB_PROJECT:
self.load_project(self.name)
def __init__(self, dnac, name, site=NO_SITES, verify=False, timeout=5):
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = SITE_HEALTH_RESOURCE_PATH[
dnac.version] # change when a site resource becomes available
self.__site_health_resource = SITE_HEALTH_RESOURCE_PATH[
dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__sites = site
self.__site_health = NO_SITE_HEALTH
super(Site, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
def __init__(self, dnac, id, verify=False, timeout=5):
"""
Deployment's __init__ method sets up a new Deployment object.
It takes a Dnac object and the deployment UUID and then constructs
a Deployment object whose name is 'deployment_<UUID>'.
Parameters:
dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: yes
id: The UUID in Cisco DNA Center for the deployment job.
type: str
default: none
required: no
verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
timeout: The number of seconds to wait for Cisco DNAC's
response.
type: int
default: 5
required: no
Return Values:
Deployment object: a new Deployment object.
Usage:
None. Template objects automatically create Deployment objects.
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = DEPLOYMENT_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__id = id
self.__url = '%s/%s' % (path, self.__id)
self.__status = '' # for monitoring deployment status
self.__results = {} # stores deployment's results
super(Deployment, self).__init__(dnac, ('deployment_%s' % self.__id),
resource=path,
verify=verify,
timeout=timeout)
def __init__(
self,
dnac,
site_name_hierarchy, # use the site's name hierarchy to ensure uniqueness
verify=False,
timeout=5):
"""
Creates a new Site object and loads its information from the Cisco DNA Center cluster specified.
:param dnac: The Cisco DNAC cluster object from which to load the site's information.
type: Dnac object
required: yes
default: none
:param site_name_hierarchy: The site's full hierarchy name as given in Cisco DNA Center, e.g. Global/US/CA
type: str
required: yes
default: none
:param verify: A flag indicating whether or not to verify the cluster's certificate.
type: bool
required: no
default: False
:param timeout: The number of seconds to wait for a site API call to complete before abandoning the response.
type: int
required: no
default: 5
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = SITE_RESOURCE_PATH[dnac.version]
self.__site_health_resource = SITE_HEALTH_RESOURCE_PATH[
dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__site = NO_SITE
self.__site_health = NO_SITE_HEALTH
super(Site, self).__init__(dnac,
site_name_hierarchy,
resource=path,
verify=verify,
timeout=timeout)
if site_name_hierarchy != STUB_SITE:
self.load_site(site_name_hierarchy)
def get_device_detail_by_mac(self, mac):
"""
get_device_detail_by_mac searches for a devices using its MAC address
and returns a detailed listing of its current configuration state
and health.
Parameters:
mac: str
default: None
required: yes
Return Values:
dict: A dictionary of the device's current state
Usage:
d = Dnac()
nd = NetworkDevice(d, 'network-device')
mac = 'DE:AD:BE:EF:01:02'
details = d.api['network-device'].get_device_detail_by_mac(mac)
pprint.PrettyPrint(details)
"""
if not self.__detail_resource:
raise DnacError(
'get_device_detail_by_mac: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, self.dnac.version)
)
time = TimeStamp()
query = '?timestamp=%s&searchBy=%s&identifier=%s' % \
(time, mac, DEVICE_DETAIL_IDENTIFIERS['mac'])
url = self.dnac.url + self.__detail_resource + query
detail, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_device_detail_by_mac', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(detail)
)
self.__device_detail = detail['response']
return self.__device_detail
def __init__(self,
dnac,
name,
mac=NULL_MAC,
verify=False,
timeout=5):
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = CLIENT_RESOURCE_PATH[dnac.version]
else:
raise DnacError(
'__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version)
)
self.__mac = mac
self.__client_detail = {}
super(Client, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
def __init__(self,
dnac,
name,
verify=False,
timeout=5):
"""
The ConfigArchiveSettings __init__ method creates a new object with blank settings.
:param dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: yes
:param name: A user friendly name for finding this object in a Dnac instance.
type: str
default: none
required: yes
:param verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
:param timeout: The number of seconds to wait for Cisco DNAC's response.
type: int
default: 5
required: no
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = ARCHIVE_SETTINGS_RESOURCE_PATH[dnac.version]
else:
raise DnacError(
'__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version)
)
self.__settings = {} # global DNA Center archive settings
super(ConfigArchiveSettings, self).__init__(dnac,
'%s_archive_settings' % name,
resource=path,
verify=verify,
timeout=timeout)
def get_site_count(self):
"""
Makes a call to the Cisco DNA Center cluster requesting the total number of sites available.
:return: int
"""
# get the number of sites in the hierarchy
if self.dnac.version in SUPPORTED_DNAC_VERSIONS:
count_path = SITE_COUNT_RESOURCE_PATH[self.dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, self.dnac.version))
url = '%s%s%s' % (self.dnac.url, self.resource, count_path)
response, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_site_count', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], '')
self.__site_count = response['response']
if self.__site_count <= NO_SITES:
raise DnacApiError(MODULE, 'get_site_count', NO_SITES_ERROR, '',
'', '', '', '')
return self.__site_count
def __init__(self, dnac, name, mac=NULL_MAC, verify=False, timeout=5):
"""
Creates a new client object.
:param dnac: A reference to the program's Dnac instance.
type: Dnac object
required: yes
default: None
:param name: The client's name.
type: str
required: yes
default: None
:param mac: The client's MAC address
type: str
required: no
default: NULL_MAC (00:00:00:00:00:00)
:param verify: A flag to determine whether or not to verify Cisco DNA Center's certificate.
type: bool
required: no
default: False
:param timeout: The time in seconds to wait for Cisco DNAC's response.
type: int
required: no
default: 5
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = CLIENT_RESOURCE_PATH[dnac.version]
else:
raise DnacError('__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__mac = mac
self.__client_detail = {}
super(Client, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
def __init__(self,
dnac,
device_id,
version_id,
verify=False,
timeout=5):
"""
Instantiates a new Version object.
:param dnac: A reference to the master script's Dnac object.
type: Dnac object
required: yes
default: None
:param device_id: The UUID for the device whose archive is being managed.
type: str
required: yes
default: none
:param version_id: The UUID of the version being queried.
type: str
required: yes
default: None
:param verify: A flag that determines whether or not Cisco DNA Center's certificate should be authenticated.
type: bool
required: no
default: False
:param timeout: The number of seconds to wait for Cisco DNAC to respond to a query.
type: int
required: no
default: 5
"""
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = '%s/%s%s/%s' % (VERSION_RESOURCE_PATH[dnac.version],
device_id,
VERSION_SUB_RESOURCE_PATH[dnac.version],
version_id)
else:
raise DnacError('__init__: %s: %s' % (UNSUPPORTED_DNAC_VERSION, dnac.version))
self.__id = version_id
self.__device_id = device_id
self.__config_files = {} # key = fileType, value = File object
name = 'version_%s' % self.__id
super(Version, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
# load the version
url = self.dnac.url + self.resource
version, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, '__init__', REQUEST_NOT_OK, url, OK, status, ERROR_MSGS[status], str(version)
)
self.__created_time = version['versions'][0]['createdTime']
self.__sync_status = version['versions'][0]['startupRunningStatus']
for file in version['versions'][0]['files']:
# iterate through all the archive's versions and load the config files
if file['fileType'] not in CONFIG_FILE_TYPES:
# ignore VLAN data files
if file['fileType'] == VLAN:
continue
raise DnacApiError(
MODULE, '__init__', ILLEGAL_CONFIG_FILE_TYPE, '',
str(CONFIG_FILE_TYPES), '', file['fileType'], ''
)
config_file = File(dnac, file['fileId'])
config_file.get_results(is_json=False)
self.__config_files[file['fileType']] = config_file
def __init__(self,
dnac,
name,
version=0,
verify=False,
timeout=5):
"""
Template's __init__ method constructs a new Template object.
It automatically searches for the template in Cisco DNA Center
by the Template's name. If found, then it will search for the
committed version of the template according to the value passed
in the version keyword argument. If no version is selected, it
chooses the latest version available.
Parameters:
dnac: A reference to the containing Dnac object.
type: Dnac object
default: none
required: yes
name: The template's exact name, including its case, in
Cisco DNA Center.
type: str
default: none
required: yes
version: The template version that will be deployed. When set
to zero, Template selects the latest version.
type: int
default: 0
required: no
verify: A flag used to check Cisco DNAC's certificate.
type: boolean
default: False
required: no
timeout: The number of seconds to wait for Cisco DNAC's
response.
type: int
default: 5
required: no
Return Values:
Template object: a newly build Template instance.
Usage:
d = Dnac()
template = Template(d, 'Enable BGP', version=5)
"""
# version is the template's version and must not be negative
if version < 0:
raise DnacApiError(
MODULE, '__init__', ILLEGAL_VERSION, '', '',
version, '', LEGAL_VERSIONS
)
# check Cisco DNA Center's version and set the resource path
if dnac.version in SUPPORTED_DNAC_VERSIONS:
path = TEMPLATE_RESOURCE_PATH[dnac.version]
else:
raise DnacError(
'__init__: %s: %s' %
(UNSUPPORTED_DNAC_VERSION, dnac.version)
)
# setup initial attribute values
self.__template_id = '' # base template ID
self.__version = version # requested template version, 0 = latest
self.__versioned_template = {}
self.__versioned_template_id = '' # template that can be deployed
self.__versioned_template_params = {}
self.__target_id = '' # where to deploy the template
self.__target_type = TARGET_BY_DEFAULT # how to find the target
self.__deployment = '' # object for monitoring the deployment
super(Template, self).__init__(dnac,
name,
resource=path,
verify=verify,
timeout=timeout)
# retrieve the template ID by its name
self.__template_id = self.get_template_by_name(self.name)
if not self.__template_id: # template could not be found
raise DnacApiError(
MODULE, '__init__', TEMPLATE_NOT_FOUND, '',
'', self.__template_id, '', ''
)
# retrieve the versioned template
# get_versioned_template_by_name sets self.__versioned_template
self.get_versioned_template_by_name(self.name, self.__version)
if not bool(self.__versioned_template): # template is empty
# get_versioned_template_by_name should catch this condition, but
# just in case, here's another integrity check
raise DnacApiError(
MODULE, '__init__', UNKNOWN_VERSION, '',
'', self.__versioned_template, '',
'%s version %i' % (self.name, self.__version)
)
