def get_client_detail(self):
"""
Get method get_client_detail makes a call to Cisco DNAC, retrieves the Client's state information,
stores it in the client_detail attribute, and also returns the results for further processing.
Parameters:
None
Return Values:
dict: the Client's detailed state
Usage:
d = Dnac()
host = Client(d, 'myPC', mac='a1:b2:c3:d4:e5:f6')
pprint.PrettyPrint(d.api['myPC'].get_client_detail)
"""
if self.__mac in ILLEGAL_MAC_ADDRS:
raise DnacApiError(
MODULE, 'get_client_detail', ILLEGAL_MAC, '',
'', self.__mac, '', ''
)
time = TimeStamp()
query = '?timestamp=%s&macAddress=%s' % (time, self.__mac)
url = self.dnac.url + self.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_client_detail', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(detail)
)
self.__client_detail = detail
return self.__client_detail
def get_devices_by_name_with_regex(self, regex):
"""
The get_devices_by_name_with_regex searches through Cisco DNA Center's inventory for all devices whose hostname
matches the regular expression it is given.
:param regex: A regular expression to find a device or set of network devices.
type: str
default: none
required: yes
:return: list of dict
"""
host_filter = '?hostname=' + regex
url = self.dnac.url + self.resource + host_filter
devices, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_devices_by_name_with_regex(',
REQUEST_NOT_OK, url, OK, status,
ERROR_MSGS[status], str(devices))
if not devices['response']: # device list is empty
raise DnacApiError(MODULE, 'get_devices_by_name_with_regex(',
NO_DEVICES, url, '', str(devices['response']),
'', CHECK_REGEX)
self.__devices = devices['response']
return self.__devices
def commit_template(self, comments='', timeout=5):
"""
The commit_template updates the parent template to its next version. Once completed, the actual template
can be deployed in Cisco DNA Center.
:param comments: Comments for the commit action
type: str
required: no
default: ''
:return: Template object
"""
body = {'templateId': self.template_id, 'comments': comments}
url = '%s%s%s' % (self.dnac.url, self.resource,
TEMPLATE_VERSION_PATH[self.dnac.version])
results, status = self.crud.post(url,
headers=self.dnac.hdrs,
body=json.dumps(body),
verify=self.verify,
timeout=timeout)
if status != ACCEPTED:
raise DnacApiError(MODULE, 'version_template',
REQUEST_NOT_ACCEPTED, url, ACCEPTED, status,
ERROR_MSGS[status], '')
# check the tasks' results
task = Task(self.dnac, results['response']['taskId'])
task.get_task_results()
if task.is_error:
raise DnacApiError(MODULE, 'version_template',
TEMPLATE_VERSION_FAILED, '', '', '', '',
task.failure_reason)
# version succeeded - reload the template and its versions
return self.load_template(self.name)
def get_devices_by_ip_with_regex(self, regex):
"""
The get_devices_by_ip_with_regex searches through Cisco DNA Center's inventory for all devices whose
management IP address matches the regular expression passed.
:param regex: A regular expression of the IP addresses to search.
type: str
default: none
required: yes
:return: list of dict
"""
url = self.dnac.url + self.resource + \
('?managementIpAddress=%s' % regex)
devices, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_devices_by_ip_with_regex',
REQUEST_NOT_OK, url, OK, status,
ERROR_MSGS[status], str(devices))
if not devices['response']: # device list is empty
raise DnacApiError(MODULE, 'get_devices_by_ip_with_regex',
NO_DEVICES, url, '', str(devices['response']),
'', CHECK_REGEX)
self.__devices = devices['response']
return self.__devices
def add_project(self, project):
"""
Adds a project to Cisco DNA Center
:param project: The project data represented as a dict
:return: Project object
"""
# add the project to Cisco DNA Center
url = '%s%s' % (self.dnac.url, self.resource)
self.__clean_project__(project)
body = json.dumps(project)
results, status = self.crud.post(url,
headers=self.dnac.hdrs,
body=body,
verify=self.verify,
timeout=self.timeout)
if status != ACCEPTED:
raise DnacApiError(
MODULE, 'import_project', REQUEST_NOT_ACCEPTED, url, ACCEPTED, status, ERROR_MSGS[status], ''
)
# check the tasks' results
task = Task(self.dnac, results['response']['taskId'])
task.get_task_results()
if task.is_error:
raise DnacApiError(MODULE, 'import_project', PROJECT_IMPORT_FAILED, '', '', '', '', task.failure_reason)
# import succeeded; create a new Project object, add it to Dnac and return it
return Project(self.dnac, project['name'])
def get_all_sites(self):
"""
Places an API call to the hierarchy's Cisco DNA Center cluster for all sites listed in its design hierarchy.
:return: dict
"""
self.__all_sites = []
self.get_site_count()
(rounds, remainder) = divmod(self.__site_count, SITE_REQUEST_LIMIT)
if remainder > 0:
rounds += 1
if self.__site_count <= NO_SITES:
raise DnacApiError(MODULE, 'get_all_sites', NO_SITES_ERROR, '', '',
'', '', '')
i = 0
offset = 1
filter = '?offset=%i&limit=%i' % (offset, SITE_REQUEST_LIMIT)
url = '%s%s%s' % (self.dnac.url, self.resource, filter)
while i < rounds:
# get the next batch of sites
response, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_all_sites', REQUEST_NOT_OK,
url, OK, status, ERROR_MSGS[status], '')
self.__all_sites = self.__all_sites + response['response']
offset += SITE_REQUEST_LIMIT
i += 1
return self.__all_sites
def get_device_by_name(self, name):
"""
get_device_by_name finds a device in Cisco DNAC using its hostname.
:param name: The device's hostname.
type : str
default: none
required: yes
:return: list with a single dict
"""
host_filter = '?hostname=' + name
url = self.dnac.url + self.resource + host_filter
devices, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_device_by_name', REQUEST_NOT_OK,
url, OK, status, ERROR_MSGS[status],
str(devices))
if not devices['response']: # device list is empty
raise DnacApiError(MODULE,
'get_device_by_name', NO_DEVICES, url, '',
str(devices['response']), '', CHECK_HOSTNAME)
self.__devices = devices['response'][0]
return self.__devices
def deploy(self):
"""
The deploy method asynchronously applies a template to a device. The Template's target information and
versioned template data must be set prior to issuing this command. The function creates a Deployment object,
saves it, and then instructs it to perform a progress check on itself and then returns whatever Cisco DNA
Center responds with. Developers can then use the deployment instance to further monitor the job's success
or failure.
:return: str
"""
url = self.dnac.url + self.resource + '/deploy'
if not self.__target_id: # target_id is not set
raise DnacApiError(MODULE, 'deploy', EMPTY_TEMPLATE, url, '',
self.__target_id, '', NO_TEMPLATE_ID)
if self.__target_type not in VALID_TARGET_TYPES:
raise DnacApiError(
MODULE, 'deploy', ILLEGAL_TARGET_TYPE, url,
str(VALID_TARGET_TYPES), self.__target_type, '',
'%s is not one of %s' %
(self.__target_type, str(VALID_TARGET_TYPES)))
body = self.__make_body__()
results, status = self.crud.post(url,
headers=self.dnac.hdrs,
body=body,
verify=self.verify,
timeout=self.timeout)
if status != ACCEPTED:
raise DnacApiError(MODULE, 'check_deployment',
REQUEST_NOT_ACCEPTED, url, ACCEPTED, status,
ERROR_MSGS[status], str(results))
# DNAC 1.2.8 references a deploymentId in a string
if self.dnac.version == '1.2.8':
did = results['response']['deploymentId']
elts = did.split()
deploy_id = elts[len(elts) - 1]
# DNAC 1.2.10 uses a task that references a deploymentId in a string
elif self.dnac.version in POST_1_2_8:
taskUrl = '%s%s' % (self.dnac.url, results['response']['url'])
task, status = self.crud.get(taskUrl,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
progress = task['response']['progress']
progress_elts = progress.split(': ')
if progress_elts[3].find(
TEMPLATE_ALREADY_DEPLOYED) != SUBSTR_NOT_FOUND:
raise DnacApiError(MODULE, 'deploy_sync', ALREADY_DEPLOYED, '',
'', str(body), status,
ALREADY_DEPLOYED_RESOLUTION)
deploy_id = progress_elts[len(progress_elts) - 1]
else:
raise DnacApiError(MODULE, 'deploy', UNSUPPORTED_DNAC_VERSION, '',
'', self.dnac.version, '', '')
self.__deployment = Deployment(self.dnac, deploy_id)
return self.__deployment.check_deployment()
def load_sites(self):
"""
Instructs the SiteHierarchy object to load all sites from the Cisco DNA Center's site design hierarchy. This
method can be used to load a new hierarchy object or to refresh one that has sites which have been added or
deleted.
:return: dict
"""
self.get_all_sites()
# find the site hierarchy's root: siteNameHierarchy = "Global"
global_site_node = None
for site in self.__all_sites:
if site['siteNameHierarchy'] != GLOBAL_SITE:
continue
else: # found the root
global_site = Site(self.dnac, GLOBAL_SITE)
global_site_node = SiteNode(global_site)
self.add_site_node(global_site_node)
break
if global_site_node is None:
raise DnacApiError(MODULE, 'load_sites', NO_GLOBAL_SITE_ERROR, '',
'', str(global_site_node), '', '')
# starting from the global site, load all children recursively
#
# need a throttle here; this is where the majority of the site calls are being made
# perhaps the throttle should be part of a SiteHierarchy instance?
#
self.__load_children__(global_site_node)
return self.__site_nodes
def get_device_by_id(self, id):
"""
get_device_by_id finds a device in Cisco DNAC using its UUID.
Parameters:
id : str
default: none
required: yes
Return Values:
list: A list with a single dictionary for the UUID requested.
Usage:
d = Dnac()
nd = NetworkDevice(d, 'network-device')
d.api[nd.name] = nd
uuid = '84e4b133-2668-4705-8163-5694c84e78fb'
device = d.api['network-device'].get_device_by_id(uuid)
pprint.PrettyPrint(device)
"""
url = self.dnac.url + self.resource + ('/%s' % id)
devices, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_device_by_id', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(devices)
)
self.__devices = devices['response']
return self.__devices
def get_all_templates(self):
"""
Class method getAllTemplates queries the Cisco DNA Center cluster
for a listing of every template it has. The listing includes
the base templates and all of its versions.
Parameters:
none
Return Values:
list: A listing of all available templates.
Usage:
d = Dnac()
template = Template(d, 'Set VLAN')
print str(d.api['Set Vlan'].getAllTemplates)
"""
url = self.dnac.url + self.resource
templates, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_all_templates', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(templates)
)
return templates
def check_deployment(self):
"""
Deployment's check_deployment method makes an API call to Cisco
DNA Center and collects the deploy job's current status and
and results it returns. It stores the data received in the
object's __results and the job's status in __status. It returns
__status to the calling function.
Parameters:
none
Return Values:
str: The job's run status.
Usage:
d = Dnac()
job = Deployment(d, id=<uuid>)
print job.check_deployment()
"""
# prepare the API call
url = self.dnac.url + self.url
# make the call
results, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
# return the results
if status != ACCEPTED:
raise DnacApiError(MODULE, 'check_deployment',
REQUEST_NOT_ACCEPTED, url, ACCEPTED, status,
ERROR_MSGS[status], str(results))
self.__results = results
self.__status = self.__results['status']
return self.__status
def get_site_health_by_name(self, site_name):
"""
The get_site_health_by_name returns the site health information for the named site.
Parameters:
site_name: The target site's name
type: str
default: none
required: yes
Return Values:
dict: The site's health details.
Usage:
d = Dnac()
all_sites = Site(d, 'ACME_sites')
target_site = 'AZ Branch'
pprint.PrettyPrint(d.api['ACME_sites'].get_site_health_by_name(target_site))
"""
target_site_health = NO_SITE_HEALTH
all_sites_health = self.get_all_sites_health()
for site_health in all_sites_health:
if site_health['siteName'] == site_name:
target_site_health = site_health
break # found the target site
else:
continue # keep searching
if target_site_health == NO_SITE_HEALTH: # site not found
raise DnacApiError(MODULE, 'get_all_sites_health', SITE_NOT_FOUND,
'', site_name, '', '',
SITE_NOT_FOUND_RESOLUTION)
self.__site_health = target_site_health
return self.__site_health
def version(self, version):
"""
The version set method changes the desired version of the template
to be deployed. This method also updates the versioned template,
its UUID and its parameters in this class' respective attributes.
See class method get_versioned_template_by_name for details. If the
requested version does not exist, an exception is thrown.
Parameters:
version: The new template version.
type: int
default: none
required: yes
Return Values:
none
Usage:
d = Dnac()
template = Template(d, 'Set VLAN')
template.version = 5
"""
self.__version = version
# reload versioned template info using get_versioned_template_by_name
self.get_versioned_template_by_name(self.name, self.__version)
# if the version requested does not exist, raise an exception
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, 'version setter', UNKNOWN_VERSION, '',
'', self.__versioned_template, '',
'%s version %i' % (self.name, version)
)
def run(self):
"""
Method run instructs Cisco DNAC to execute the command set stored in
the CommandRunner object. It does not wait for the task to
complete on Cisco DNA Center. It does, however, create a new Task
object, saves it in the __task attribute, checks the task, and
then returns the task's status. See the task.py module for
valid task states. When using this function, the programmer
must handle task monitoring.
Parameters:
none
Return Values:
str: The current state of the command's progress.
Usage:
d = Dnac()
cmd = CommandRunner(d, 'aName')
cmdState = cmd.run()
"""
url = self.dnac.url + self.resource
results, status = self.crud.post(url,
headers=self.dnac.hdrs,
body=self.__cmds,
verify=self.verify,
timeout=self.timeout)
if status != ACCEPTED:
raise DnacApiError(MODULE, 'run', REQUEST_NOT_ACCEPTED, url,
ACCEPTED, status, ERROR_MSGS[status],
str(results))
task_id = results['response']['taskId']
self.__task = Task(self.dnac, task_id)
return self.__task.check_task()
def get_all_sites_health(self):
"""
Site class method get_all_sites_health retrieves the current health details for all sites in
Cisco DNA Center.
Parameters:
None
Return Values:
dict: The health details for all sites.
Usage:
d = Dnac()
all_sites = Site(d, 'ACME_sites')
pprint.PrettyPrint(d.api['ACME_sites'].get_all_sites_health())
"""
time = TimeStamp()
query = '?timestamp=%s' % time
url = self.dnac.url + self.resource + query
health, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_all_sites_health', REQUEST_NOT_OK,
url, OK, status, ERROR_MSGS[status],
str(health))
self.__site_health = health['response']
return self.__site_health
def get_all_devices(self):
"""
The get_all_devices method returns every network device managed
by Cisco DNA Center.
Parameters:
none
Return Values:
list: A list of dictionaries. Each dictionary contains the
attributes of a single device managed by Cisco DNAC.
Usage:
d = Dnac()
nd = NetworkDevice(d, 'network-device')
d.api[nd.name] = nd
devices = d.api['network-device'].get_all_devices()
for device in devices:
pprint.PrettyPrint(device['hostname'])
"""
url = self.dnac.url + self.resource
devices, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_all_devices', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(devices)
)
self.__devices = devices['response']
return self.__devices
def get_results(self):
"""
get_results makes an API call to Cisco DNA Center and retrieves the
task results contained in the file identified by this object's
__file_id, i.e. the file's UUID.
Parameters:
none
Return Values:
list: The file's or task result's data.
Usage:
d = Dnac()
task = Task(d, 'aTask')
task.checkTask()
# task.file below is a File object
results = task.file.get_results()
"""
url = self.dnac.url + self.resource + ('/%s' % self.__id)
results, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'get_results', REQUEST_NOT_OK, url, OK,
status, ERROR_MSGS[status], str(results))
self.__results = results
return self.__results
def get_template_by_id(self, id):
"""
get_template_by_id pulls the template information for the one
specified by the UUID passed to the function. Either base or
versioned templates may be queried.
Parameters:
id: The UUID of a template.
type: str
default: none
required: yes
Return Values:
dict: The template's data.
Usage:
d = Dnac()
template = Template(d, 'Set VLAN')
print str(d.api['Set Vlan'].get_template_by_id('<template_uuid>')
"""
url = self.dnac.url + self.resource + '/' + id
template, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_template_by_id', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(template)
)
return template
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 delete(self):
"""
Removes the Version object from Cisco DNA Center as well as from the program's Dnac object.
:return: None
"""
url = self.dnac.url + self.resource
results, status = self.crud.delete(url, headers=self.dnac.hdrs)
if status != OK:
raise DnacApiError(MODULE, 'delete', REQUEST_NOT_OK, url, OK, status, ERROR_MSGS[status], '')
task = Task(self.dnac, results['response']['taskId'])
task.get_task_results()
if task.is_error:
raise DnacApiError(MODULE, 'delete', task.progress, '', '', '', task.failure_reason, '')
else:
# remove self from Dnac.api{}
del self.dnac.api[self.name]
def get_vlans_by_device_ip(self, ip):
"""
get_vlans_by_device_ip obtains the list of VLANs configured on the
device given its IP address.
Parameters:
ip : str
default: none
required: yes
Return Values:
list: The list of VLANs on the network device.
Usage:
d = Dnac()
nd = NetworkDevice(d, 'network-device')
ip = '10.255.1.10'
vlans = d.api['network-device'].get_vlans_by_device_ip(ip)
pprint.PrettyPrint(vlans)
"""
device = self.get_device_by_ip(ip)
url = self.dnac.url + self.resource + \
('/%s/l2vlan' % device['id'])
vlans, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_vlans_by_device_ip', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(vlans)
)
self.__vlans = vlans['response']
return self.__vlans
def get_vlans_by_device_id(self, id):
"""
get_vlans_by_device_id obtains the list of VLANs configured on the
device given by its UUID.
Parameters:
id : str
default: none
required: yes
Return Values:
list: The list of VLANs on the network device.
Usage:
d = Dnac()
nd = NetworkDevice(d, 'network-device')
id = 'a0116157-3a02-4b8d-ad89-45f45ecad5da'
vlans = d.api['network-device'].get_vlans_by_device_id(id)
print str(vlans)
"""
url = self.dnac.url + self.resource + ('/%s/l2vlan' % id)
vlans, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_vlans_by_device_id', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(vlans)
)
self.__vlans = vlans['response']
return self.__vlans
def add_new_template(self, template, project, timeout=5):
"""
Creates a new template in Cisco DNA Center and assigns it to the project provided.
:param template: The template information constructed from a json formatted string
type: dict
required: yes
default: None
:param project: A reference to the project to which the template should be assigned
type: Project object
required: yes
default: None
:return: Template object
"""
# ensure the template is correctly formatted
self.__is_versioned_template__(template)
# prepare the template for import
template = self.__prepare_template__(template)
# add the template into DNA Center
url = '%s%s/%s/template' % (self.dnac.url,
PROJECT_RESOURCE_PATH[self.dnac.version],
project.project_id)
body = json.dumps(template)
results, status = self.crud.post(url,
headers=self.dnac.hdrs,
body=body,
verify=self.verify,
timeout=timeout)
if status != ACCEPTED:
if status == _500_:
raise DnacApiError(MODULE, 'add_new_template',
REQUEST_NOT_ACCEPTED, url, ACCEPTED, status,
ERROR_MSGS[status], TEMPLATE_ALREADY_EXISTS)
else:
raise DnacApiError(MODULE, 'add_new_template',
REQUEST_NOT_ACCEPTED, url, ACCEPTED, status,
ERROR_MSGS[status], '')
# check the tasks' results
task = Task(self.dnac, results['response']['taskId'])
task.get_task_results()
if task.is_error:
raise DnacApiError(MODULE, 'add_new_template',
TEMPLATE_IMPORT_FAILED, '', '', '', '',
task.failure_reason)
# import succeeded; reload the project and return the new template
project.load_project(project.name)
return Template(self.dnac, template['name'])
def add_version(self, version, timeout=5):
"""
Creates a new version of an existing template.
:param version: The new version to be added to Cisco DNAC
type: dict constructed from a json formatted file
required: yes
default: None
:return: Template object
"""
# ensure the template is correctly formatted
self.__is_versioned_template__(version)
# check if the template associated with the new version is already in Dnac
if version['name'] not in self.dnac.api:
# if not, throw an error
raise DnacApiError(MODULE, 'add_version',
'%s %s' % (TEMPLATE_NOT_FOUND, version['name']),
'', '', '', '', CALL_ADD_NEW_TEMPLATE)
else:
# if so, save a pointer to it
template = self.dnac.api[version['name']]
# prepare the new version
self.__prepare_version__(version, template)
# add the new version to DNAC
url = '%s%s' % (self.dnac.url,
TEMPLATE_RESOURCE_PATH[self.dnac.version])
body = json.dumps(version)
results, status = self.crud.put(url,
headers=self.dnac.hdrs,
body=body,
verify=self.verify,
timeout=timeout)
if status != ACCEPTED:
raise DnacApiError(MODULE, 'add_version', REQUEST_NOT_ACCEPTED,
url, ACCEPTED, status, ERROR_MSGS[status], '')
# check the tasks' results
task = Task(self.dnac, results['response']['taskId'])
task.get_task_results()
if task.is_error:
raise DnacApiError(MODULE, 'add_version', TEMPLATE_IMPORT_FAILED,
'', '', '', '', task.failure_reason)
# import succeeded; reload the template
return template.load_template(version['name'])
def delete_config_file(self, file_id):
"""
Removes the specified file, given by its UUID, from Cisco DNAC and from the Version instance.
:param file_id: str
:return: None
"""
url = '%s%s/%s/%s' % (self.dnac.url, self.resource, CONFIG_FILE_SUB_RESOURCE_PATH[self.dnac.version], file_id)
results, status = self.crud.delete(url, headers=self.dnac.hdrs)
if status != OK:
raise DnacApiError(MODULE, 'delete_config', REQUEST_NOT_OK, url, OK, status, ERROR_MSGS[status], '')
task = Task(self.dnac, results['response']['taskId'])
task.get_task_results()
if task.is_error:
raise DnacApiError(MODULE, 'delete_config', task.progress, '', '', '', task.failure_reason, '')
else:
for config_file_type, config_file in self.__config_files.items():
if file_id == config_file.id:
del self.__config_files[config_file_type]
break
del self.dnac.api['file_%s' % file_id]
def load_template(self, name):
"""
The load_template method searches Cisco DNA Center for the template named. If found, it loads the base
template information and all available versions. Use this function to prepare new Template objects or to
refresh existing ones when they have changed. Many methods in the Template class automatically call this
function. It should be rare for a user to have to call this method.
:param name: The template's name as given in Cisco DNAC
type: str
required: yes
default: None
:return: Template object
"""
# search all templates for the target
templates = self.get_all_templates()
if bool(templates): # templates is not empty
for template in templates:
# find the template by name
if template['name'] == name:
self.__template = template
break
else: # not found - keep looking for the template by its name
continue
# make sure the template is not empty
if self.__template == TEMPLATE_IS_EMPTY:
raise DnacApiError(MODULE, 'load_template', EMPTY_TEMPLATE, '',
'', '', '', '')
else:
raise DnacApiError(MODULE, 'load_template', NO_TEMPLATES_FOUND, '',
'', '', '', '')
# load the parent template
self.__versions[0] = self.get_template_by_id(
self.__template['templateId'])
# load all committed versions
if bool(self.__template['versionsInfo']
): # at least one committed version exists
for version in self.__template['versionsInfo']:
self.__versions[int(
version['version'])] = self.get_template_by_id(
version['id'])
# all done - return the template
return self
def load_site(self, site_name_hierarchy):
"""
Using the site's fully qualified hierarchy name, this method queries the Cisco DNA center cluster for the
site's information and loads it into it's __site attribute.
:param site_name_hierarchy: The site's fully qualifies site name, e.g. Global/EU/England/London
:return: dict
"""
filter = '?name=%s' % site_name_hierarchy
url = '%s%s%s' % (self.dnac.url, self.resource, filter)
site, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(MODULE, 'load_site', REQUEST_NOT_OK, url, OK,
status, ERROR_MSGS[status], site_name_hierarchy)
if len(site['response']) != SINGLE_SITE:
raise DnacApiError(MODULE, 'load_site', MULTIPLE_SITES_FOUND, '',
SINGLE_SITE, len(site['response']), '', '')
self.__site = site['response'][0]
return self.__site
def get_devices_by_ip_with_regex(self, regex):
"""
The get_devices_by_ip_with_regex searches through Cisco DNA Center's
inventory for all devices whose management IP address matches the
regular expression passed.
Parameters:
regex: str
default: None
required: yes
Return Values:
list: The devices found according to the regular expression search.
Usage:
d = Dnac()
nd = NetworkDevice(d, 'network-device')
d.api[nd.name] = nd
regex = '192.168.*.*'
devices = d.api['network-device'].get_devices_by_ip_with_regex(regex)
pprint.PrettyPrint(devices)
"""
url = self.dnac.url + self.resource + \
('?managementIpAddress=%s' % regex)
devices, status = self.crud.get(url,
headers=self.dnac.hdrs,
verify=self.verify,
timeout=self.timeout)
if status != OK:
raise DnacApiError(
MODULE, 'get_devices_by_ip_with_regex', REQUEST_NOT_OK, url,
OK, status, ERROR_MSGS[status], str(devices)
)
if not devices['response']: # device list is empty
raise DnacApiError(
MODULE, 'get_devices_by_ip_with_regex', NO_DEVICES, url,
'', str(devices['response']), '', CHECK_REGEX
)
self.__devices = devices['response']
return self.__devices
def get_client_detail(self):
"""
Get method get_client_detail makes a call to Cisco DNAC, retrieves the Client's state information, stores it in
the client_detail attribute, and also returns the results for further processing.
:return: dict
"""
if self.__mac in ILLEGAL_MAC_ADDRS:
raise DnacApiError(MODULE, 'get_client_detail', ILLEGAL_MAC, '',
'', self.__mac, '', '')
time = TimeStamp()
query = '?timestamp=%s&macAddress=%s' % (time, self.__mac)
url = self.dnac.url + self.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_client_detail', REQUEST_NOT_OK,
url, OK, status, ERROR_MSGS[status],
str(detail))
self.__client_detail = detail
return self.__client_detail