def export_policy_to_file(self, export_file):
policy_lists = PolicyLists(self.session, self.host, self.port)
policy_definitions = PolicyDefinitions(self.session, self.host,
self.port)
local_policy = LocalPolicy(self.session, self.host, self.port)
central_policy = CentralPolicy(self.session, self.host, self.port)
policy_lists_list = policy_lists.get_policy_list_list()
policy_definitions_list = policy_definitions.get_policy_definition_list(
)
central_policies_list = central_policy.get_central_policy_list()
local_policies_list = local_policy.get_local_policy_list()
policy_export = {
'vmanage_policy_lists': policy_lists_list,
'vmanage_policy_definitions': policy_definitions_list,
'vmanage_central_policies': central_policies_list,
'vmanage_local_policies': local_policies_list
}
if export_file.endswith('.json'):
with open(export_file, 'w') as outfile:
json.dump(policy_export, outfile, indent=4, sort_keys=False)
elif export_file.endswith(('.yaml', 'yml')):
with open(export_file, 'w') as outfile:
yaml.dump(policy_export, outfile, default_flow_style=False)
else:
raise Exception("File format not supported")
def __init__(self, session, host, port=443):
"""Initialize Files object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.device_templates = DeviceTemplates(self.session, self.host,
self.port)
self.feature_templates = FeatureTemplates(self.session, self.host,
self.port)
self.template_data = TemplateData(self.session, self.host, self.port)
self.policy_data = PolicyData(self.session, self.host, self.port)
self.policy_lists = PolicyLists(self.session, self.host, self.port)
self.policy_definitions = PolicyDefinitions(self.session, self.host,
self.port)
self.local_policy = LocalPolicy(self.session, self.host, self.port)
self.central_policy = CentralPolicy(self.session, self.host, self.port)
self.vmanage_device = Device(self.session, self.host, self.port)
def run_module():
# define available arguments/parameters a user can pass to the module
argument_spec = vmanage_argument_spec()
argument_spec.update(type=dict(type='str', required=False,
default='all'), )
# seed the result dict in the object
# we primarily care about changed and state
# change is if this module effectively modified the target
# state will include any data that you want your module to pass back
# for consumption, for example, in a subsequent task
result = dict(changed=False, original_message='', message='')
# the AnsibleModule object will be our abstraction working with Ansible
# this includes instantiation, a couple of common attr would be the
# args/params passed to the execution, as well as if the module
# supports check mode
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vmanage = Vmanage(module)
vmanage_policy_lists = PolicyLists(vmanage.auth, vmanage.host)
vmanage.result['policy_lists'] = vmanage_policy_lists.get_policy_list_list(
vmanage.params['type'])
vmanage.exit_json(**vmanage.result)
def list_cmd(ctx, name, json, policy_list_type): #pylint: disable=unused-argument
"""
Show policy list information
"""
policy_lists = PolicyLists(ctx.auth, ctx.host, ctx.port)
pp = pprint.PrettyPrinter(indent=2)
if name:
policy_list_dict = policy_lists.get_policy_list_dict(policy_list_type=policy_list_type)
if name in policy_list_dict:
pp.pprint(policy_list_dict[name])
else:
policy_lists = policy_lists.get_policy_list_list(policy_list_type=policy_list_type)
pp.pprint(policy_lists)
def __init__(self, session, host, port=443):
"""Initialize Policy Lists object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.policy_lists = PolicyLists(self.session, self.host, self.port)
def __init__(self, session, host, port=443):
"""Initialize Policy Method object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.policy_lists = PolicyLists(self.session, self.host, self.port)
self.policy_definitions = PolicyDefinitions(self.session, self.host, self.port)
self.local_policy = LocalPolicy(self.session, self.host, self.port)
self.central_policy = CentralPolicy(self.session, self.host, self.port)
self.security_policy = SecurityPolicy(self.session, self.host, self.port)
def __init__(self, session, host, port=443):
"""Initialize Reset vManage object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.utilities = Utilities(self.session, self.host)
self.cen_pol = CentralizedPolicy(self.session, self.host)
self.inventory = DeviceInventory(self.session, self.host)
self.dev_temps = DeviceTemplates(self.session, self.host)
self.fet_temps = FeatureTemplates(self.session, self.host)
self.loc_pol = LocalizedPolicy(self.session, self.host)
self.sec_pol = SecurityPolicy(self.session, self.host)
self.pol_lists = PolicyLists(self.session, self.host)
def __init__(self, session, host, port=443):
"""Initialize Policy Lists object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.policy_lists = PolicyLists(self.session, self.host, self.port)
version = Utilities(self.session, self.host,
self.port).get_vmanage_version()
if version >= '19.3.0':
self.definition_types = definition_types_19_3_0
else:
self.definition_types = definition_types_19_2_0
class PolicyDefinitions(object):
"""vManage Policy Definitions API
Responsible for DELETE, GET, POST, PUT methods against vManage
Policy Definitions used in Centralized, Localized, and Security Policy.
"""
def __init__(self, session, host, port=443):
"""Initialize Policy Lists object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.policy_lists = PolicyLists(self.session, self.host, self.port)
def convert_list_id_to_name(self, id_list):
if isinstance(id_list, dict):
for key, value in list(id_list.items()):
if key.endswith('List'):
t = key[0:len(key) - 4]
policy_list_dict = self.policy_lists.get_policy_list_dict(
t, key_name='listId')
if value in policy_list_dict:
id_list[key] = policy_list_dict[value]['name']
elif key.endswith('Lists'):
t = key[0:len(key) - 5]
policy_list_dict = self.policy_lists.get_policy_list_dict(
t, key_name='listId')
new_list = []
for list_id in value:
if list_id in policy_list_dict:
list_name = policy_list_dict[list_id]['name']
new_list.append(list_name)
else:
new_list.append(list_id)
id_list[key] = new_list
elif key.endswith('Zone'):
policy_list_dict = self.policy_lists.get_policy_list_dict(
'zone', key_name='listId')
if value in policy_list_dict:
id_list[key] = policy_list_dict[value]['name']
elif key == 'ref':
policy_list_dict = self.policy_lists.get_policy_list_dict(
'all', key_name='listId')
if id_list['ref'] in policy_list_dict:
id_list['listName'] = policy_list_dict[
id_list['ref']]['name']
id_list['listType'] = policy_list_dict[
id_list['ref']]['type']
id_list.pop('ref')
else:
raise Exception("Could not find list {0}".format(
id_list['ref']))
elif key == 'class':
policy_list_dict = self.policy_lists.get_policy_list_dict(
'all', key_name='listId')
if id_list['class'] in policy_list_dict:
id_list['className'] = policy_list_dict[
id_list['class']]['name']
id_list['classType'] = policy_list_dict[
id_list['class']]['type']
id_list.pop('class')
else:
raise Exception("Could not find list {0}".format(
id_list['ref']))
else:
self.convert_list_id_to_name(value)
elif isinstance(id_list, list):
for item in id_list:
self.convert_list_id_to_name(item)
def convert_list_name_to_id(self, name_list):
if isinstance(name_list, dict):
for key, value in list(name_list.items()):
if key.endswith('List'):
t = key[0:len(key) - 4]
policy_list_dict = self.policy_lists.get_policy_list_dict(
t)
if value in policy_list_dict:
name_list[key] = policy_list_dict[value]['listId']
elif key.endswith('Lists'):
t = key[0:len(key) - 5]
policy_list_dict = self.policy_lists.get_policy_list_dict(
t)
new_list = []
for list_name in value:
if list_name in policy_list_dict:
list_id = policy_list_dict[list_name]['listId']
new_list.append(list_id)
else:
new_list.append(list_name)
name_list[key] = new_list
elif key.endswith('Zone'):
policy_list_dict = self.policy_lists.get_policy_list_dict(
'zone')
if value in policy_list_dict:
name_list[key] = policy_list_dict[value]['listId']
elif key == 'listName':
if 'listType' in name_list:
policy_list_dict = self.policy_lists.get_policy_list_dict(
name_list['listType'], key_name='name')
else:
raise Exception(
"Could not find type for list {0}".format(
name_list['listName']))
if name_list[
'listName'] in policy_list_dict and 'listId' in policy_list_dict[
name_list['listName']]:
name_list['ref'] = policy_list_dict[
name_list['listName']]['listId']
name_list.pop('listName')
name_list.pop('listType')
else:
raise Exception(
"Could not find id for list {0}, type {1}".format(
name_list['listName'], name_list['listType']))
elif key == 'className':
if 'classType' in name_list:
policy_list_dict = self.policy_lists.get_policy_list_dict(
name_list['classType'], key_name='name')
else:
raise Exception(
"Could not find type for list {0}".format(
name_list['className']))
if name_list[
'className'] in policy_list_dict and 'listId' in policy_list_dict[
name_list['className']]:
name_list['class'] = policy_list_dict[
name_list['className']]['listId']
name_list.pop('className')
name_list.pop('classType')
else:
raise Exception(
"Could not find id for list {0}, type {1}".format(
name_list['listName'], name_list['listType']))
else:
self.convert_list_name_to_id(value)
elif isinstance(name_list, list):
for item in name_list:
self.convert_list_name_to_id(item)
def convert_definition_id_to_name(self, policy_definition):
if 'assembly' in policy_definition:
for assembly_item in policy_definition['assembly']:
policy_definition_detail = self.get_policy_definition(
assembly_item['type'].lower(),
assembly_item['definitionId'])
definition_id = assembly_item.pop('definitionId')
if policy_definition_detail:
assembly_item['definitionName'] = policy_definition_detail[
'name']
else:
raise Exception(
"Cannot find policy definition for {0}".format(
definition_id))
if 'entries' in assembly_item:
# Translate list IDs to names
self.convert_list_id_to_name(assembly_item['entries'])
def convert_definition_name_to_id(self, policy_definition):
if 'assembly' in policy_definition:
for assembly_item in policy_definition['assembly']:
definition_name = assembly_item.pop('definitionName')
policy_definition_dict = self.get_policy_definition_dict(
assembly_item['type'])
if definition_name in policy_definition_dict:
assembly_item['definitionId'] = policy_definition_dict[
definition_name]['definitionId']
else:
raise Exception("Cannot find policy definition {0}".format(
definition_name))
if 'entries' in assembly_item:
self.convert_list_name_to_id(assembly_item['entries'])
def delete_policy_definition(self, definition_type, definition_id):
"""Delete a Policy Definition from vManage.
Args:
definition_type (str): The defintion type of the requested policy definition
definition_id (str): The defintion ID of the requested policy definition
Returns:
result (dict): All data associated with a response.
"""
url = f"{self.base_url}template/policy/definition/{definition_type.lower()}/{definition_id}"
HttpMethods(self.session, url).request('GET')
def add_policy_definition(self, policy_definition):
"""Delete a Policy Definition from vManage.
Args:
definition_type (str): The defintion type of the requested policy definition
definition_id (str): The defintion ID of the requested policy definition
Returns:
result (dict): All data associated with a response.
"""
url = f"{self.base_url}template/policy/definition/{policy_definition['type'].lower()}"
HttpMethods(self.session,
url).request('POST', payload=json.dumps(policy_definition))
def update_policy_definition(self, policy_definition,
policy_definition_id):
"""Update a Policy Definition from vManage.
Args:
definition_type (str): The defintion type of the requested policy definition
definition_id (str): The defintion ID of the requested policy definition
Returns:
result (dict): All data associated with a response.
"""
url = f"{self.base_url}template/policy/definition/{policy_definition['type'].lower()}/{policy_definition_id}"
HttpMethods(self.session,
url).request('PUT', payload=json.dumps(policy_definition))
def get_policy_definition(self, definition_type, definition_id):
"""Get a Policy Definition from vManage.
Args:
definition_type (str): The defintion type of the requested policy definition
definition_id (str): The defintion ID of the requested policy definition
Returns:
result (dict): All data associated with a response.
"""
api = 'template/policy/definition/{0}/{1}'.format(
definition_type.lower(), definition_id)
url = self.base_url + api
response = HttpMethods(self.session, url).request('GET')
policy_definition = response["json"]
if 'definition' in policy_definition:
self.convert_list_id_to_name(policy_definition['definition'])
if 'sequences' in policy_definition:
self.convert_list_id_to_name(policy_definition['sequences'])
if 'rules' in policy_definition:
self.convert_list_id_to_name(policy_definition['rules'])
return policy_definition
def get_policy_definition_list(self, definition_type='all'):
"""Get all Policy Definition Lists from vManage.
Args:
definition_type (string): The type of Definition List to retreive
Returns:
response (dict): A list of all definition lists currently
in vManage.
"""
if definition_type == 'all':
# Get a list of hub-and-spoke because it tells us the other definition types
# known by this server (hopefully) in the header section
all_definitions_list = []
definition_list_types = []
api = "template/policy/definition/hubandspoke"
url = self.base_url + api
response = HttpMethods(self.session, url).request('GET')
try:
definition_type_titles = response['json']['header']['columns'][
1]['keyvalue']
except:
raise Exception('Could not retrieve definition types')
for def_type in definition_type_titles:
definition_list_types.append(def_type['key'].lower())
for def_type in definition_list_types:
definition_list = self.get_policy_definition_list(def_type)
if definition_list:
all_definitions_list.extend(definition_list)
return all_definitions_list
definition_list = []
url = f"{self.base_url}template/policy/definition/{definition_type.lower()}"
response = HttpMethods(self.session, url).request('GET')
result = ParseMethods.parse_data(response)
for definition in result:
definition_detail = self.get_policy_definition(
definition_type, definition['definitionId'])
if definition_detail:
definition_list.append(definition_detail)
return definition_list
def get_policy_definition_dict(self, t, key_name='name', remove_key=False):
policy_definition_list = self.get_policy_definition_list(t)
return list_to_dict(policy_definition_list,
key_name,
remove_key=remove_key)
def convert_sequences_to_id(self, sequence_list):
for sequence in sequence_list:
if 'match' in sequence and 'entries' in sequence['match']:
for entry in sequence['match']['entries']:
if 'listName' in entry:
policy_list_dict = self.policy_lists.get_policy_list_dict(
entry['listType'])
if entry['listName'] in policy_list_dict:
entry['ref'] = policy_list_dict[
entry['listName']]['listId']
entry.pop('listName')
entry.pop('listType')
else:
raise Exception(
"Could not find list {0} of type {1}".format(
entry['listName'], entry['listType']))
#pylint: disable=unused-argument
def import_policy_definition_list(self,
policy_definition_list,
update=False,
push=False,
check_mode=False,
force=False):
policy_definition_updates = []
for definition in policy_definition_list:
policy_definition_dict = self.get_policy_definition_dict(
definition['type'], remove_key=False)
diff = []
payload = {
"name": definition['name'],
"description": definition['description'],
"type": definition['type'],
}
if 'defaultAction' in definition:
payload.update({'defaultAction': definition['defaultAction']})
if 'sequences' in definition:
payload.update({'sequences': definition['sequences']})
if 'definition' in definition:
payload.update({'definition': definition['definition']})
if definition['name'] in policy_definition_dict:
existing_definition = policy_definition_dict[
definition['name']]
if 'defaultAction' in payload:
diff.extend(
list(
dictdiffer.diff(
existing_definition['defaultAction'],
payload['defaultAction'])))
if 'sequences' in payload:
diff.extend(
list(
dictdiffer.diff(existing_definition['sequences'],
payload['sequences'])))
if 'definition' in payload:
diff.extend(
list(
dictdiffer.diff(existing_definition['definition'],
payload['definition'])))
if len(diff):
if 'definition' in definition:
self.convert_list_name_to_id(definition['definition'])
if 'sequences' in definition:
self.convert_sequences_to_id(definition['sequences'])
if 'rules' in definition:
self.convert_sequences_to_id(definition['rules'])
if not check_mode and update:
self.update_policy_definition(
definition, policy_definition_dict[
definition['name']]['definitionId'])
policy_definition_updates.append({
'name': definition['name'],
'diff': diff
})
else:
diff = list(dictdiffer.diff({}, payload))
policy_definition_updates.append({
'name': definition['name'],
'diff': diff
})
# List does not exist
if 'definition' in definition:
self.convert_list_name_to_id(definition['definition'])
if 'sequences' in definition:
self.convert_list_name_to_id(definition['sequences'])
if 'rules' in definition:
self.convert_list_name_to_id(definition['rules'])
if not check_mode:
self.add_policy_definition(definition)
return policy_definition_updates
class ResetVmanage(object):
"""Reset all configuratios on a vManage instance.
Executes the necessary REST calls in specific order to remove
configurations applied to a vManage instance.
"""
def __init__(self, session, host, port=443):
"""Initialize Reset vManage object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.utilities = Utilities(self.session, self.host)
self.cen_pol = CentralizedPolicy(self.session, self.host)
self.inventory = DeviceInventory(self.session, self.host)
self.dev_temps = DeviceTemplates(self.session, self.host)
self.fet_temps = FeatureTemplates(self.session, self.host)
self.loc_pol = LocalizedPolicy(self.session, self.host)
self.sec_pol = SecurityPolicy(self.session, self.host)
self.pol_lists = PolicyLists(self.session, self.host)
def active_count_delay(self):
activeCount = 1
while activeCount != 0:
time.sleep(1.0)
data = self.utilities.get_active_count()
activeCount = data["activeTaskCount"]
def execute(self):
# Step 1 - Deactivate Centralized Policy
data = self.cen_pol.get_centralized_policy()
for policy in data:
if policy['isPolicyActivated']:
policyId = policy['policyId']
self.cen_pol.deactivate_centralized_policy(policyId)
self.active_count_delay()
# Step 2 - Detach vedges from template
data = self.inventory.get_device_list('vedges')
for device in data:
if (('deviceIP' in device)
and (device['configOperationMode'] == 'vmanage')):
deviceId = device['uuid']
deviceIP = device['deviceIP']
deviceType = device['deviceType']
self.inventory.post_device_cli_mode(deviceId, deviceIP,
deviceType)
self.active_count_delay()
# Step 3 - Detach controllers from template
data = self.inventory.get_device_list('controllers')
for device in data:
if (('deviceIP' in device)
and (device['configOperationMode'] == 'vmanage')):
deviceId = device['uuid']
deviceIP = device['deviceIP']
deviceType = device['deviceType']
self.inventory.post_device_cli_mode(deviceId, deviceIP,
deviceType)
# Requires pause between controllers
self.active_count_delay()
self.active_count_delay()
# Step 4 - Delete All Device Templates
data = self.dev_temps.get_device_templates()
for device in data:
templateId = device['templateId']
self.dev_temps.delete_device_template(templateId)
self.active_count_delay()
# Step 5 - Delete All Feature Templates
data = self.fet_temps.get_feature_templates()
for device in data:
#pylint: disable=no-else-continue
if device['factoryDefault']:
continue
else:
templateId = device['templateId']
self.fet_temps.delete_feature_template(templateId)
self.active_count_delay()
# Step 6 - Delete All Centralized Policies
data = self.cen_pol.get_centralized_policy()
for policy in data:
policyId = policy['policyId']
self.cen_pol.delete_centralized_policy(policyId)
self.active_count_delay()
# Step 7 - Delete All Topology, Traffic, Cflowd Policies
definitionList = [
'control', 'mesh', 'hubandspoke', 'vpnmembershipgroup', 'approute',
'data', 'cflowd'
]
for definition in definitionList:
data = self.cen_pol.get_policy_definition(definition)
if data:
for policy in data:
definitionId = policy['definitionId']
self.cen_pol.delete_policy_definition(
definition, definitionId)
self.active_count_delay()
# Step 8 - Delete All Localized Policies
data = self.loc_pol.get_localized_policy()
for policy in data:
policyId = policy['policyId']
self.loc_pol.delete_localized_policy(policyId)
self.active_count_delay()
# Step 9 - Delete All Localized Specific Definitions
definitionList = [
'qosmap', 'rewriterule', 'acl', 'aclv6', 'vedgeroute'
]
for definition in definitionList:
data = self.loc_pol.get_localized_definition(definition)
if data:
for policy in data:
definitionId = policy['definitionId']
self.loc_pol.delete_localized_definition(
definition, definitionId)
self.active_count_delay()
# Step 10 - Delete All Security Policies
version = self.utilities.get_vmanage_version()
if version >= '18.2.0':
data = self.sec_pol.get_security_policy()
for policy in data:
policyId = policy['policyId']
self.sec_pol.delete_security_policy(policyId)
self.active_count_delay()
# Step 11 - Delete All UTD Specific Security Policies
version = self.utilities.get_vmanage_version()
definitionList = []
# TODO: implement a proper semver comparison, this will fail if version is 18.30.0
if version >= '18.4.0':
definitionList = [
'zonebasedfw', 'urlfiltering', 'dnssecurity',
'intrusionprevention', 'advancedMalwareProtection'
]
#pylint: disable=chained-comparison
if version < '18.4.0' and version >= '18.2.0':
definitionList = ['zonebasedfw']
if definitionList:
for definition in definitionList:
data = self.sec_pol.get_security_definition(definition)
if data:
for policy in data:
definitionId = policy['definitionId']
self.sec_pol.delete_security_definition(
definition, definitionId)
self.active_count_delay()
# Step 12 - Delete All Lists
data = self.pol_lists.get_policy_list_all()
for policy_list in data:
owner = policy_list['owner']
if owner != 'system':
listType = policy_list['type'].lower()
listId = policy_list['listId']
self.pol_lists.delete_policy_list(listType, listId)
return ('Reset Complete')
def import_policy_from_file(self,
file,
update=False,
check_mode=False,
push=False):
vmanage_policy_lists = PolicyLists(self.session, self.host, self.port)
vmanage_policy_definitions = PolicyDefinitions(self.session, self.host,
self.port)
vmanage_central_policy = CentralPolicy(self.session, self.host,
self.port)
vmanage_local_policy = LocalPolicy(self.session, self.host, self.port)
policy_list_updates = []
policy_definition_updates = []
central_policy_updates = []
local_policy_updates = []
# Read in the datafile
if not os.path.exists(file):
raise Exception('Cannot find file {0}'.format(file))
with open(file) as f:
if file.endswith('.yaml') or file.endswith('.yml'):
policy_data = yaml.safe_load(f)
else:
policy_data = json.load(f)
# Separate the feature template data from the device template data
if 'vmanage_policy_lists' in policy_data:
policy_list_data = policy_data['vmanage_policy_lists']
else:
policy_list_data = []
if 'vmanage_policy_definitions' in policy_data:
policy_definition_data = policy_data['vmanage_policy_definitions']
else:
policy_definition_data = []
if 'vmanage_central_policies' in policy_data:
central_policy_data = policy_data['vmanage_central_policies']
else:
central_policy_data = []
if 'vmanage_local_policies' in policy_data:
local_policy_data = policy_data['vmanage_local_policies']
else:
local_policy_data = []
policy_list_updates = vmanage_policy_lists.import_policy_list_list(
policy_list_data, check_mode=check_mode, update=update, push=push)
vmanage_policy_lists.clear_policy_list_cache()
policy_definition_updates = vmanage_policy_definitions.import_policy_definition_list(
policy_definition_data,
check_mode=check_mode,
update=update,
push=push)
central_policy_updates = vmanage_central_policy.import_central_policy_list(
central_policy_data,
check_mode=check_mode,
update=update,
push=push)
local_policy_updates = vmanage_local_policy.import_local_policy_list(
local_policy_data, check_mode=check_mode, update=update, push=push)
return {
'policy_list_updates': policy_list_updates,
'policy_definition_updates': policy_definition_updates,
'central_policy_updates': central_policy_updates,
'local_policy_updates': local_policy_updates
}
def run_module():
# define available arguments/parameters a user can pass to the module
argument_spec = vmanage_argument_spec()
argument_spec.update(state=dict(type='str',
choices=['absent', 'present'],
default='present'),
aggregate=dict(type='list'),
name=dict(type='str'),
description=dict(type='str'),
type=dict(type='str',
required=False,
choices=[
'all', 'color', 'vpn', 'site', 'app',
'dataprefix', 'prefix', 'aspath',
'class', 'community', 'extcommunity',
'mirror', 'tloc', 'sla', 'policer',
'ipprefixall', 'dataprefixall'
],
default='all'),
entries=dict(type='list'),
update=dict(type='bool', default=False),
push=dict(type='bool', default=False),
force=dict(type='bool', default=False))
# seed the result dict in the object
# we primarily care about changed and state
# change is if this module effectively modified the target
# state will include any data that you want your module to pass back
# for consumption, for example, in a subsequent task
result = dict(changed=False, )
# the AnsibleModule object will be our abstraction working with Ansible
# this includes instantiation, a couple of common attr would be the
# args/params passed to the execution, as well as if the module
# supports check mode
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vmanage = Vmanage(module)
vmanage_policy_lists = PolicyLists(vmanage.auth, vmanage.host)
# Always as an aggregate... make a list if just given a single entry
if vmanage.params['aggregate']:
policy_list_list = vmanage.params['aggregate']
else:
policy_list_list = [{
"name": vmanage.params['name'],
"description": vmanage.params['description'],
"type": vmanage.params['type'],
"entries": vmanage.params['entries'],
}]
# Import site lists
policy_list_updates = []
if vmanage.params['state'] == 'present':
policy_list_updates = vmanage_policy_lists.import_policy_list_list(
policy_list_list,
check_mode=module.check_mode,
update=vmanage.params['update'],
push=vmanage.params['push'])
if policy_list_updates:
vmanage.result['changed'] = True
else:
policy_list_dict = vmanage_policy_lists.get_policy_list_dict(
vmanage.params['type'], remove_key=False)
for policy_list in policy_list_list:
if policy_list['name'] in policy_list_dict:
diff = list(dictdiffer.diff({}, policy_list))
policy_list_updates.append({
'name': policy_list['name'],
'diff': diff
})
if not module.check_mode:
vmanage_policy_lists.delete_policy_list(
policy_list['type'].lower(), policy_list['listId'])
vmanage.result['changed'] = True
vmanage.params['updates'] = policy_list_updates
vmanage.exit_json(**vmanage.result)
class PolicyData(object):
"""Methods that deal with importing, exporting, and manipulating data from policies.
"""
def __init__(self, session, host, port=443):
"""Initialize Policy Method object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.policy_lists = PolicyLists(self.session, self.host, self.port)
self.policy_definitions = PolicyDefinitions(self.session, self.host, self.port)
self.local_policy = LocalPolicy(self.session, self.host, self.port)
self.central_policy = CentralPolicy(self.session, self.host, self.port)
self.security_policy = SecurityPolicy(self.session, self.host, self.port)
#pylint: disable=unused-argument
def import_policy_list_list(self, policy_list_list, push=False, update=False, check_mode=False, force=False):
"""Import a list of policyies lists into vManage. Object Names are translated to IDs.
Args:
policy_list_list: A list of polcies
push (bool): Whether to push a change out
update (bool): Whether to update when the list exists
check_mode (bool): Report what updates would happen, but don't update
Returns:
result (dict): All data associated with a response.
"""
# Policy Lists
diff = []
policy_list_updates = []
#pylint: disable=too-many-nested-blocks
for policy_list in policy_list_list:
policy_list_dict = self.policy_lists.get_policy_list_dict(policy_list['type'],
remove_key=False,
cache=False)
if policy_list['name'] in policy_list_dict:
existing_list = policy_list_dict[policy_list['name']]
diff_ignore = set(
['listId', 'references', 'lastUpdated', 'activatedId', 'policyId', 'listId', 'isActivatedByVsmart'])
diff = list(dictdiffer.diff(existing_list, policy_list, ignore=diff_ignore))
if diff:
policy_list_updates.append({'name': policy_list['name'], 'diff': diff})
policy_list['listId'] = policy_list_dict[policy_list['name']]['listId']
# If description is not specified, try to get it from the existing information
if not policy_list['description']:
policy_list['description'] = policy_list_dict[policy_list['name']]['description']
if not check_mode and update:
response = self.policy_lists.update_policy_list(policy_list)
if response['json']:
# Updating the policy list returns a `processId` that locks the list and 'masterTemplatesAffected'
# that lists the templates affected by the change.
if 'error' in response['json']:
raise Exception(response['json']['error']['message'])
elif 'processId' in response['json']:
if push:
vmanage_device_templates = DeviceTemplates(self.session, self.host)
# If told to push out the change, we need to reattach each template affected by the change
for template_id in response['json']['masterTemplatesAffected']:
vmanage_device_templates.reattach_device_template(template_id)
else:
raise Exception("Did not get a process id when updating policy list")
else:
diff = list(dictdiffer.diff({}, policy_list))
policy_list_updates.append({'name': policy_list['name'], 'diff': diff})
if not check_mode:
self.policy_lists.add_policy_list(policy_list)
return policy_list_updates
def convert_list_name_to_id(self, name_list):
"""Convert policy list from names to IDs in object.
Args:
name_list (list): Object
"""
if isinstance(name_list, dict):
for key, value in list(name_list.items()):
if key.endswith('List') and key != "signatureWhiteList":
t = key[0:len(key) - 4]
policy_list = self.policy_lists.get_policy_list_by_name(value, policy_list_type=t)
if policy_list:
name_list[key] = policy_list['listId']
else:
raise Exception(f"Could not find id for list {value}, type {t}")
elif key.endswith('Lists'):
t = key[0:len(key) - 5]
new_list = []
for list_name in value:
policy_list = self.policy_lists.get_policy_list_by_name(list_name, policy_list_type=t)
if policy_list:
list_id = policy_list['listId']
new_list.append(list_id)
else:
raise Exception(f"Could not find id for list {list_name}, type {t}")
name_list[key] = new_list
elif key.endswith('Zone'):
policy_list = self.policy_lists.get_policy_list_by_name(value, 'zone')
if policy_list:
name_list[key] = policy_list['listId']
else:
raise Exception(f"Could not find id for list {value}, type zone")
elif key == 'listName':
if 'listType' in name_list:
policy_list = self.policy_lists.get_policy_list_by_name(name_list['listName'],
policy_list_type=name_list['listType'])
else:
raise Exception(f"Could not find type for list {name_list['listName']}")
if policy_list and 'listId' in policy_list:
name_list['ref'] = policy_list['listId']
name_list.pop('listName')
name_list.pop('listType')
else:
raise Exception(
f"Could not find id for list {name_list['listName']}, type {name_list['listType']}")
elif key == 'className':
if 'classType' in name_list:
policy_list = self.policy_lists.get_policy_list_by_name(name_list['className'],
policy_list_type=name_list['classType'])
else:
raise Exception(f"Could not find type for list {name_list['className']}")
if policy_list and 'listId' in policy_list:
name_list['class'] = policy_list['listId']
name_list.pop('className')
name_list.pop('classType')
else:
raise Exception(
f"Could not find id for list {name_list['className']}, type {name_list['classType']}")
else:
self.convert_list_name_to_id(value)
elif isinstance(name_list, list):
for item in name_list:
self.convert_list_name_to_id(item)
def convert_list_id_to_name(self, id_list):
"""Convert policy list from IDs to names in object.
Args:
id_list (list): Object
"""
if isinstance(id_list, dict):
for key, value in list(id_list.items()):
if key.endswith('List') and key != "signatureWhiteList":
t = key[0:len(key) - 4]
val = value
if isinstance(value, list):
val = value[0]
policy_list = self.policy_lists.get_policy_list_by_id(val, policy_list_type=t)
if policy_list:
id_list[key] = policy_list['name']
else:
raise Exception(f"Could not find name for list id {val}, type {t}")
elif key.endswith('Lists'):
t = key[0:len(key) - 5]
new_list = []
for list_id in value:
policy_list = self.policy_lists.get_policy_list_by_id(list_id, policy_list_type=t)
if policy_list:
list_name = policy_list['name']
new_list.append(list_name)
else:
raise Exception(f"Could not find name for list id {list_id}, type {t}")
id_list[key] = new_list
elif key.endswith('Zone'):
policy_list = self.policy_lists.get_policy_list_by_id(value, 'zone')
if policy_list:
id_list[key] = policy_list['name']
else:
raise Exception(f"Could not find name for list {value}, type zone")
elif key == 'ref':
policy_list = self.policy_lists.get_policy_list_by_id(id_list['ref'])
if policy_list:
id_list['listName'] = policy_list['name']
id_list['listType'] = policy_list['type']
id_list.pop('ref')
else:
raise Exception(f"Could not find name for list {id_list['ref']}")
elif key == 'class':
policy_list = self.policy_lists.get_policy_list_by_id(id_list['class'])
if policy_list:
id_list['className'] = policy_list['name']
id_list['classType'] = policy_list['type']
id_list.pop('class')
else:
raise Exception(f"Could not find name for list {id_list['class']}")
else:
self.convert_list_id_to_name(value)
elif isinstance(id_list, list):
for item in id_list:
self.convert_list_id_to_name(item)
def convert_sequences_to_id(self, sequence_list):
"""Convert sequence entries from IDs to names in object.
Args:
sequence_list (list): Sequence list
"""
for sequence in sequence_list:
if 'match' in sequence and 'entries' in sequence['match']:
for entry in sequence['match']['entries']:
if 'listName' in entry:
policy_list_dict = self.policy_lists.get_policy_list_dict(entry['listType'])
if entry['listName'] in policy_list_dict:
entry['ref'] = policy_list_dict[entry['listName']]['listId']
entry.pop('listName')
entry.pop('listType')
else:
raise Exception("Could not find list {0} of type {1}".format(
entry['listName'], entry['listType']))
def convert_definition_id_to_name(self, policy_definition):
"""Convert policy_definition from IDs to names in object.
Args:
policy_definition (list): Sequence list
"""
if 'assembly' in policy_definition and policy_definition['assembly']:
for assembly_item in policy_definition['assembly']:
policy_definition_detail = self.policy_definitions.get_policy_definition(
assembly_item['type'].lower(), assembly_item['definitionId'])
definition_id = assembly_item.pop('definitionId')
if policy_definition_detail:
assembly_item['definitionName'] = policy_definition_detail['name']
else:
raise Exception("Cannot find policy definition for {0}".format(definition_id))
if 'entries' in assembly_item:
# Translate list IDs to names
self.convert_list_id_to_name(assembly_item['entries'])
def convert_definition_name_to_id(self, policy_definition):
"""Convert policy_definition from names to IDs in object.
Args:
policy_definition (list): Sequence list
"""
if 'assembly' in policy_definition and policy_definition['assembly']:
for assembly_item in policy_definition['assembly']:
definition_name = assembly_item.pop('definitionName')
policy_definition_dict = self.policy_definitions.get_policy_definition_dict(assembly_item['type'])
if definition_name in policy_definition_dict:
assembly_item['definitionId'] = policy_definition_dict[definition_name]['definitionId']
else:
raise Exception("Cannot find policy definition {0}".format(definition_name))
if 'entries' in assembly_item:
self.convert_list_name_to_id(assembly_item['entries'])
def convert_policy_definition_to_name(self, policy_definition):
"""Convert policy_definition objects from IDs to names
Args:
policy_definition (list): Sequence list
Returns:
result (dict): The converted policy definition
"""
converted_policy_definition = policy_definition
if 'definition' in policy_definition:
self.convert_list_id_to_name(policy_definition['definition'])
if 'sequences' in policy_definition:
self.convert_list_id_to_name(policy_definition['sequences'])
if 'rules' in policy_definition:
self.convert_list_id_to_name(policy_definition['rules'])
return converted_policy_definition
def convert_policy_definition_to_id(self, policy_definition):
"""Convert policy_definition objects from names to IDs
Args:
policy_definition (list): Sequence list
Returns:
result (dict): The converted policy definition
"""
converted_policy_definition = policy_definition
if 'definition' in policy_definition:
self.convert_list_name_to_id(policy_definition['definition'])
if 'sequences' in policy_definition:
self.convert_list_name_to_id(policy_definition['sequences'])
if 'rules' in policy_definition:
self.convert_list_name_to_id(policy_definition['rules'])
return converted_policy_definition
def export_policy_definition_list(self, definition_type='all'):
"""Export Policy Definition Lists from vManage, translating IDs to Names.
Args:
definition_type (string): The type of Definition List to retreive
Returns:
response (list): A list of all definition lists currently
in vManage.
"""
policy_definition_list = self.policy_definitions.get_policy_definition_list(definition_type)
export_definition_list = []
for policy_definition in policy_definition_list:
definition_detail = self.policy_definitions.get_policy_definition(policy_definition['type'],
policy_definition['definitionId'])
converted_policy_definition = self.convert_policy_definition_to_name(definition_detail)
export_definition_list.append(converted_policy_definition)
return export_definition_list
#pylint: disable=unused-argument
def import_policy_definition_list(self,
policy_definition_list,
update=False,
push=False,
check_mode=False,
force=False):
"""Import Policy Definitions into vManage. Object names are converted to IDs.
Returns:
response (dict): A list of all policy lists currently
in vManage.
"""
policy_definition_updates = []
for definition in policy_definition_list:
policy_definition_dict = self.policy_definitions.get_policy_definition_dict(definition['type'],
remove_key=False)
diff = []
payload = {
"name": definition['name'],
"description": definition['description'],
"type": definition['type'],
}
if 'defaultAction' in definition:
payload.update({'defaultAction': definition['defaultAction']})
if 'sequences' in definition:
payload.update({'sequences': definition['sequences']})
if 'definition' in definition:
payload.update({'definition': definition['definition']})
if definition['name'] in policy_definition_dict:
existing_definition = self.convert_policy_definition_to_name(policy_definition_dict[definition['name']])
# Just check the things that we care about changing.
diff_ignore = set([
'lastUpdated', 'definitionId', 'referenceCount', 'references', 'owner', 'isActivatedByVsmart',
'infoTag', 'activatedId'
])
diff = list(dictdiffer.diff(existing_definition, payload, ignore=diff_ignore))
if diff:
converted_definition = self.convert_policy_definition_to_id(definition)
policy_definition_updates.append({'name': converted_definition['name'], 'diff': diff})
if not check_mode and update:
self.policy_definitions.update_policy_definition(
converted_definition, policy_definition_dict[converted_definition['name']]['definitionId'])
policy_definition_updates.append({'name': converted_definition['name'], 'diff': diff})
else:
# Policy definition does not exist
diff = list(dictdiffer.diff({}, payload))
policy_definition_updates.append({'name': definition['name'], 'diff': diff})
converted_definition = self.convert_policy_definition_to_id(definition)
if not check_mode:
self.policy_definitions.add_policy_definition(converted_definition)
return policy_definition_updates
def convert_policy_to_name(self, policy_item):
"""Convert policy items from IDs to names
Args:
definition_type (string): Policy item
Returns:
response (dict): The converted policy item
"""
if 'policyDefinition' in policy_item:
converted_policy_item = policy_item
self.convert_definition_id_to_name(converted_policy_item['policyDefinition'])
return converted_policy_item
return policy_item
def convert_policy_to_id(self, policy_item):
"""Convert policy items from names IDs
Args:
definition_type (string): Policy item
Returns:
response (dict): The converted policy item
"""
if 'policyDefinition' in policy_item:
converted_policy_item = policy_item
self.convert_definition_name_to_id(converted_policy_item['policyDefinition'])
return converted_policy_item
return policy_item
def export_local_policy_list(self):
"""Export Local Policies from vManage. Object IDs are converted to names.
Returns:
response (dict): A list of all policy lists currently
in vManage.
"""
export_policy_list = []
local_policy_list = self.local_policy.get_local_policy_list()
for local_policy in local_policy_list:
converted_policy_definition = self.convert_policy_to_name(local_policy)
export_policy_list.append(converted_policy_definition)
return export_policy_list
#pylint: disable=unused-argument
def import_local_policy_list(self, local_policy_list, update=False, push=False, check_mode=False, force=False):
"""Import Local Policies into vManage. Object names are converted to IDs.
Returns:
response (dict): A list of all policy lists currently
in vManage.
"""
local_policy_dict = self.local_policy.get_local_policy_dict(remove_key=False)
diff = []
local_policy_updates = []
for local_policy in local_policy_list:
payload = {'policyName': local_policy['policyName']}
payload['policyDescription'] = local_policy['policyDescription']
payload['policyType'] = local_policy['policyType']
payload['policyDefinition'] = local_policy['policyDefinition']
if payload['policyName'] in local_policy_dict:
# A policy by that name already exists
existing_policy = self.convert_policy_to_name(local_policy_dict[payload['policyName']])
diff_ignore = set([
'lastUpdated', 'policyVersion', 'createdOn', 'references', 'isPolicyActivated', '@rid', 'policyId',
'createdBy', 'lastUpdatedBy', 'lastUpdatedOn', 'mastersAttached', 'policyDefinitionEdit',
'devicesAttached'
])
diff = list(dictdiffer.diff(existing_policy, payload, ignore=diff_ignore))
if diff:
print(diff)
local_policy_updates.append({'name': local_policy['policyName'], 'diff': diff})
if 'policyDefinition' in payload:
self.convert_definition_name_to_id(payload['policyDefinition'])
if not check_mode and update:
self.local_policy.update_local_policy(payload, existing_policy['policyId'])
else:
diff = list(dictdiffer.diff({}, payload['policyDefinition']))
local_policy_updates.append({'name': local_policy['policyName'], 'diff': diff})
if 'policyDefinition' in payload:
# Convert list and definition names to template IDs
self.convert_definition_name_to_id(payload['policyDefinition'])
if not check_mode:
self.local_policy.add_local_policy(payload)
return local_policy_updates
def export_central_policy_list(self):
"""Export Central Policies from vManage, converting IDs to names.
Returns:
response (dict): A list of all policy lists currently
in vManage.
"""
export_policy_list = []
central_policy_list = self.central_policy.get_central_policy_list()
for central_policy in central_policy_list:
converted_policy_definition = self.convert_policy_to_name(central_policy)
export_policy_list.append(converted_policy_definition)
return export_policy_list
#pylint: disable=unused-argument
def import_central_policy_list(self, central_policy_list, update=False, push=False, check_mode=False, force=False):
"""Import Central Policies into vManage. Object names are converted to IDs.
Returns:
response (dict): A list of all policy lists currently
in vManage.
"""
central_policy_dict = self.central_policy.get_central_policy_dict(remove_key=False)
diff = []
central_policy_updates = []
for central_policy in central_policy_list:
payload = {'policyName': central_policy['policyName']}
payload['policyDescription'] = central_policy['policyDescription']
payload['policyType'] = central_policy['policyType']
payload['policyDefinition'] = central_policy['policyDefinition']
if payload['policyName'] in central_policy_dict:
# A policy by that name already exists
existing_policy = self.convert_policy_to_name(central_policy_dict[payload['policyName']])
diff_ignore = set([
'lastUpdated', 'policyVersion', 'createdOn', 'references', 'isPolicyActivated', '@rid', 'policyId',
'createdBy', 'lastUpdatedBy', 'lastUpdatedOn'
])
diff = list(dictdiffer.diff(existing_policy, payload, ignore=diff_ignore))
if diff:
central_policy_updates.append({'name': central_policy['policyName'], 'diff': diff})
# Convert list and definition names to template IDs
converted_payload = self.convert_policy_to_id(payload)
if not check_mode and update:
self.central_policy.update_central_policy(converted_payload, existing_policy['policyId'])
else:
diff = list(dictdiffer.diff({}, payload['policyDefinition']))
central_policy_updates.append({'name': central_policy['policyName'], 'diff': diff})
if not check_mode:
# Convert list and definition names to template IDs
converted_payload = self.convert_policy_to_id(payload)
self.central_policy.add_central_policy(converted_payload)
return central_policy_updates
def export_security_policy_list(self):
"""Export Security Policies from vManage, converting IDs to names.
Returns:
response (dict): A list of all policy lists currently
in vManage.
"""
export_policy_list = []
security_policy_list = self.security_policy.get_security_policy_list()
for security_policy in security_policy_list:
converted_policy_definition = self.convert_policy_to_name(security_policy)
export_policy_list.append(converted_policy_definition)
return export_policy_list
def import_security_policy_list(self,
security_policy_list,
update=False,
push=False,
check_mode=False,
force=False):
"""Import Security Policies into vManage. Object names are converted to IDs.
Returns:
response (dict): A list of all policy lists currently
in vManage.
"""
security_policy_dict = self.security_policy.get_security_policy_dict(remove_key=False)
diff = []
security_policy_updates = []
for security_policy in security_policy_list:
payload = {'policyName': security_policy['policyName']}
payload['policyDescription'] = security_policy['policyDescription']
payload['policyType'] = security_policy['policyType']
payload['policyDefinition'] = security_policy['policyDefinition']
if payload['policyName'] in security_policy_dict:
# A policy by that name already exists
existing_policy = self.convert_policy_to_name(security_policy_dict[payload['policyName']])
diff_ignore = set([
'lastUpdated', 'policyVersion', 'createdOn', 'references', 'isPolicyActivated', '@rid', 'policyId',
'createdBy', 'lastUpdatedBy', 'lastUpdatedOn', 'policyDefinitionEdit', 'mastersAttached',
'devicesAttached', 'supportedDevices', 'virtualApplicationTemplates', 'policyUseCase'
])
diff = list(dictdiffer.diff(existing_policy, payload, ignore=diff_ignore))
if diff:
security_policy_updates.append({'name': security_policy['policyName'], 'diff': diff})
# Convert list and definition names to template IDs
converted_payload = self.convert_policy_to_id(payload)
if not check_mode and update:
self.security_policy.update_security_policy(converted_payload, existing_policy['policyId'])
else:
diff = list(dictdiffer.diff({}, payload['policyDefinition']))
security_policy_updates.append({'name': security_policy['policyName'], 'diff': diff})
if not check_mode:
# Convert list and definition names to template IDs
converted_payload = self.convert_policy_to_id(payload)
self.security_policy.add_security_policy(converted_payload)
return security_policy_updates
class CleanVmanage(object):
"""Reset all configuratios on a vManage instance.
Executes the necessary REST calls in specific order to remove
configurations applied to a vManage instance.
"""
def __init__(self, session, host, port=443):
"""Initialize Reset vManage object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.utilities = Utilities(self.session, self.host)
self.central_policy = CentralPolicy(self.session, self.host)
self.local_policy = LocalPolicy(self.session, self.host)
self.device = Device(self.session, self.host)
self.device_templates = DeviceTemplates(self.session, self.host)
self.feature_templates = FeatureTemplates(self.session, self.host)
self.sec_pol = SecurityPolicy(self.session, self.host)
self.policy_definitions = PolicyDefinitions(self.session, self.host)
self.policy_lists = PolicyLists(self.session, self.host)
def active_count_delay(self):
"""Delay while there are active tasks.
"""
activeCount = 1
while activeCount != 0:
time.sleep(1.0)
data = self.utilities.get_active_count()
activeCount = data["activeTaskCount"]
def clean_vedge_attachments(self):
"""Clean all vedge attachments
"""
data = self.device.get_device_list('vedges')
for device in data:
if (('deviceIP' in device) and (device['configOperationMode'] == 'vmanage')):
deviceId = device['uuid']
deviceIP = device['deviceIP']
deviceType = device['deviceType']
self.device.post_device_cli_mode(deviceId, deviceIP, deviceType)
self.active_count_delay()
def clean_controller_attachments(self):
"""Clean all controller attachments
"""
data = self.device.get_device_list('controllers')
for device in data:
if (('deviceIP' in device) and (device['configOperationMode'] == 'vmanage')):
deviceId = device['uuid']
deviceIP = device['deviceIP']
deviceType = device['deviceType']
self.device.post_device_cli_mode(deviceId, deviceIP, deviceType)
# Requires pause between controllers
self.active_count_delay()
self.active_count_delay()
def clean_device_templates(self):
"""Clean all device templates
"""
data = self.device_templates.get_device_templates()
for device in data:
templateId = device['templateId']
self.device_templates.delete_device_template(templateId)
self.active_count_delay()
def clean_feature_templates(self):
"""Clean all feature templates
"""
data = self.feature_templates.get_feature_templates()
for device in data:
#pylint: disable=no-else-continue
if device['factoryDefault']:
continue
else:
templateId = device['templateId']
self.feature_templates.delete_feature_template(templateId)
self.active_count_delay()
def clean_central_policy(self):
"""Clean all central policy
"""
data = self.central_policy.get_central_policy()
for policy in data:
policy_id = policy['policyId']
if policy['isPolicyActivated']:
action_id = self.central_policy.deactivate_central_policy(policy_id)
if action_id:
self.utilities.waitfor_action_completion(action_id)
self.central_policy.delete_central_policy(policy_id)
self.active_count_delay()
def clean_local_policy(self):
"""Clean all local policy
"""
data = self.local_policy.get_local_policy()
for policy in data:
policyId = policy['policyId']
self.local_policy.delete_local_policy(policyId)
self.active_count_delay()
def clean_policy_definitions(self):
"""Clean all policy definitions
"""
policy_definition_list = self.policy_definitions.get_policy_definition_list()
for policy_definition in policy_definition_list:
self.policy_definitions.delete_policy_definition(policy_definition['type'],
policy_definition['definitionId'])
self.active_count_delay()
def clean_policy_lists(self):
"""Clean all policy lists
"""
policy_list_list = self.policy_lists.get_policy_list_list()
for policy_list in policy_list_list:
if not policy_list['readOnly'] and policy_list['owner'] != 'system':
self.policy_lists.delete_policy_list(policy_list['type'], policy_list['listId'])
self.active_count_delay()
def clean_security_policy(self):
"""Clean all security policy
"""
version = self.utilities.get_vmanage_version()
if version >= '18.2.0':
data = self.sec_pol.get_security_policy()
for policy in data:
policyId = policy['policyId']
self.sec_pol.delete_security_policy(policyId)
self.active_count_delay()
# # Step 11 - Delete All UTD Specific Security Policies
# version = self.utilities.get_vmanage_version()
# definitionList = []
# # TODO: implement a proper semver comparison, this will fail if version is 18.30.0
# if version >= '18.4.0':
# definitionList = [
# 'zonebasedfw', 'urlfiltering', 'dnssecurity', 'intrusionprevention', 'advancedMalwareProtection'
# ]
# #pylint: disable=chained-comparison
# if version < '18.4.0' and version >= '18.2.0':
# definitionList = ['zonebasedfw']
# if definitionList:
# for definition in definitionList:
# data = self.sec_pol.get_security_definition(definition)
# if data:
# for policy in data:
# definitionId = policy['definitionId']
# self.sec_pol.delete_security_definition(definition, definitionId)
# self.active_count_delay()
# # Step 12 - Delete All Lists
# data = self.pol_lists.get_policy_list_all()
# for policy_list in data:
# owner = policy_list['owner']
# if owner != 'system':
# listType = policy_list['type'].lower()
# listId = policy_list['listId']
# self.pol_lists.delete_policy_list(listType, listId)
def clean_all(self):
"""Clean everything in vManage
"""
# Step 1 - Deactivate Central Policy
self.clean_central_policy()
# Step 2 - Detach vedges from template
self.clean_vedge_attachments()
# Step 3 - Detach controllers from template
self.clean_controller_attachments()
# Step 4 - Delete All Device Templates
self.clean_device_templates()
# Step 5 - Delete All Feature Templates
self.clean_feature_templates()
# Step 6 - Delete All Centralized Policies
self.clean_central_policy()
# Step 7 - Delete All Policy Definitions
self.clean_policy_definitions()
# Step 8 - Delete All Policy Lists
self.clean_policy_lists()
# Step 9 - Delete All Local Policies
self.clean_local_policy()
# Step 10 - Delete All Security Policies
self.clean_security_policy()
return ('Reset Complete')
class Files(object):
"""Read and write data to file.
"""
def __init__(self, session, host, port=443):
"""Initialize Files object with session parameters.
Args:
session (obj): Requests Session object
host (str): hostname or IP address of vManage
port (int): default HTTPS 443
"""
self.session = session
self.host = host
self.port = port
self.base_url = f'https://{self.host}:{self.port}/dataservice/'
self.device_templates = DeviceTemplates(self.session, self.host, self.port)
self.feature_templates = FeatureTemplates(self.session, self.host, self.port)
self.template_data = TemplateData(self.session, self.host, self.port)
self.policy_data = PolicyData(self.session, self.host, self.port)
self.policy_lists = PolicyLists(self.session, self.host, self.port)
self.policy_definitions = PolicyDefinitions(self.session, self.host, self.port)
self.local_policy = LocalPolicy(self.session, self.host, self.port)
self.central_policy = CentralPolicy(self.session, self.host, self.port)
self.security_policy = SecurityPolicy(self.session, self.host, self.port)
self.vmanage_device = Device(self.session, self.host, self.port)
def export_templates_to_file(self, export_file, name_list=None, template_type=None):
"""Export templates to a file. All object IDs will be translated to names. Use
a '.yml' extention to export as YAML and a '.json' extension to export as JSON.
Args:
export_file (str): The name of the export file
name_list (list): List of device templates to export
template_type (str): Template type: device or template
"""
template_export = {}
#pylint: disable=too-many-nested-blocks
if template_type != 'feature':
# Export the device templates and associated feature templates
device_template_list = self.template_data.export_device_template_list(name_list=name_list)
template_export.update({'vmanage_device_templates': device_template_list})
feature_name_list = []
if name_list:
for device_template in device_template_list:
if 'generalTemplates' in device_template:
for general_template in device_template['generalTemplates']:
if 'templateName' in general_template:
feature_name_list.append(general_template['templateName'])
if 'subTemplates' in general_template:
for sub_template in general_template['subTemplates']:
if 'templateName' in sub_template:
feature_name_list.append(sub_template['templateName'])
name_list = list(set(feature_name_list))
# Since device templates depend on feature templates, we always add them.
feature_template_list = self.feature_templates.get_feature_template_list(name_list=name_list)
template_export.update({'vmanage_feature_templates': feature_template_list})
if export_file.endswith('.json'):
with open(export_file, 'w') as outfile:
json.dump(template_export, outfile, indent=4, sort_keys=False)
elif export_file.endswith('.yaml') or export_file.endswith('.yml'):
with open(export_file, 'w') as outfile:
yaml.dump(template_export, outfile, indent=4, sort_keys=False)
else:
raise Exception("File format not supported")
#pylint: disable=unused-argument
def import_templates_from_file(self,
import_file,
update=False,
check_mode=False,
name_list=None,
template_type=None):
"""Import templates from a file. All object Names will be translated to IDs.
Args:
import_file (str): The name of the import file
name_list (list): List of device templates to export
template_type (str): Template type: device or template
check_mode (bool): Try the import, but don't make changes (default: False)
update (bool): Update existing templates (default: False)
"""
feature_template_updates = []
device_template_updates = []
imported_template_data = {}
# Read in the datafile
if not os.path.exists(import_file):
raise Exception(f"Cannot find file {import_file}")
with open(import_file) as f:
if import_file.endswith('.yaml') or import_file.endswith('.yml'):
imported_template_data = yaml.safe_load(f)
else:
imported_template_data = json.load(f)
if 'vmanage_feature_templates' in imported_template_data:
imported_feature_template_list = imported_template_data['vmanage_feature_templates']
else:
imported_feature_template_list = []
imported_device_template_list = []
#pylint: disable=too-many-nested-blocks
if template_type != 'feature':
# Import the device templates and associated feature templates
if 'vmanage_device_templates' in imported_template_data:
imported_device_template_list = imported_template_data['vmanage_device_templates']
if name_list:
feature_name_list = []
pruned_device_template_list = []
for device_template in imported_device_template_list:
if device_template['templateName'] in name_list:
pruned_device_template_list.append(device_template)
if 'generalTemplates' in device_template:
for general_template in device_template['generalTemplates']:
if 'templateName' in general_template:
feature_name_list.append(general_template['templateName'])
if 'subTemplates' in general_template:
for sub_template in general_template['subTemplates']:
if 'templateName' in sub_template:
feature_name_list.append(sub_template['templateName'])
imported_device_template_list = pruned_device_template_list
name_list = list(set(feature_name_list))
# Since device templates depend on feature templates, we always add them.
if name_list:
pruned_feature_template_list = []
imported_feature_template_dict = list_to_dict(imported_feature_template_list,
key_name='templateName',
remove_key=False)
for feature_template_name in name_list:
if feature_template_name in imported_feature_template_dict:
pruned_feature_template_list.append(imported_feature_template_dict[feature_template_name])
# Otherwise, we hope the feature list is already there (e.g. Factory Default)
imported_feature_template_list = pruned_feature_template_list
# Process the feature templates
feature_template_updates = self.template_data.import_feature_template_list(imported_feature_template_list,
check_mode=check_mode,
update=update)
# Process the device templates
device_template_updates = self.template_data.import_device_template_list(imported_device_template_list,
check_mode=check_mode,
update=update)
return {
'feature_template_updates': feature_template_updates,
'device_template_updates': device_template_updates,
}
#
# Policy
#
def export_policy_to_file(self, export_file):
"""Export policy to a file. All object IDs will be translated to names. Use
a '.yml' extention to export as YAML and a '.json' extension to export as JSON.
Args:
export_file (str): The name of the export file
"""
policy_lists_list = self.policy_lists.get_policy_list_list()
policy_definitions_list = self.policy_data.export_policy_definition_list()
central_policies_list = self.policy_data.export_central_policy_list()
local_policies_list = self.local_policy.get_local_policy_list()
security_policies_list = self.policy_data.export_security_policy_list()
policy_export = {
'vmanage_policy_lists': policy_lists_list,
'vmanage_policy_definitions': policy_definitions_list,
'vmanage_central_policies': central_policies_list,
'vmanage_local_policies': local_policies_list,
'vmanage_security_policies': security_policies_list
}
if export_file.endswith('.json'):
with open(export_file, 'w') as outfile:
json.dump(policy_export, outfile, indent=4, sort_keys=False)
elif export_file.endswith(('.yaml', 'yml')):
with open(export_file, 'w') as outfile:
yaml.dump(policy_export, outfile, default_flow_style=False)
else:
raise Exception("File format not supported")
def import_policy_from_file(self, file, update=False, check_mode=False, push=False):
"""Import policy from a file. All object Names will be translated to IDs.
Args:
import_file (str): The name of the import file
check_mode (bool): Try the import, but don't make changes (default: False)
update (bool): Update existing templates (default: False)
push (bool): Push tempaltes to devices if changed (default: False)
"""
policy_list_updates = []
policy_definition_updates = []
central_policy_updates = []
local_policy_updates = []
security_policy_updates = []
# Read in the datafile
if not os.path.exists(file):
raise Exception('Cannot find file {0}'.format(file))
with open(file) as f:
if file.endswith('.yaml') or file.endswith('.yml'):
policy_data = yaml.safe_load(f)
else:
policy_data = json.load(f)
# Separate the feature template data from the device template data
if 'vmanage_policy_lists' in policy_data:
policy_list_data = policy_data['vmanage_policy_lists']
else:
policy_list_data = []
if 'vmanage_policy_definitions' in policy_data:
policy_definition_data = policy_data['vmanage_policy_definitions']
else:
policy_definition_data = []
if 'vmanage_central_policies' in policy_data:
central_policy_data = policy_data['vmanage_central_policies']
else:
central_policy_data = []
if 'vmanage_local_policies' in policy_data:
local_policy_data = policy_data['vmanage_local_policies']
else:
local_policy_data = []
if 'vmanage_security_policies' in policy_data:
security_policy_data = policy_data['vmanage_security_policies']
else:
security_policy_data = []
policy_list_updates = self.policy_data.import_policy_list_list(policy_list_data,
check_mode=check_mode,
update=update,
push=push)
self.policy_lists.clear_policy_list_cache()
policy_definition_updates = self.policy_data.import_policy_definition_list(policy_definition_data,
check_mode=check_mode,
update=update,
push=push)
central_policy_updates = self.policy_data.import_central_policy_list(central_policy_data,
check_mode=check_mode,
update=update,
push=push)
local_policy_updates = self.policy_data.import_local_policy_list(local_policy_data,
check_mode=check_mode,
update=update,
push=push)
security_policy_updates = self.policy_data.import_security_policy_list(security_policy_data,
check_mode=check_mode,
update=update,
push=push)
return {
'policy_list_updates': policy_list_updates,
'policy_definition_updates': policy_definition_updates,
'central_policy_updates': central_policy_updates,
'local_policy_updates': local_policy_updates,
'security_policy_updates': security_policy_updates
}
def export_attachments_to_file(self, export_file, name_list=None, device_type=None):
"""Export attachments to a file. All object IDs will be translated to names. Use
a '.yml' extention to export as YAML and a '.json' extension to export as JSON.
Args:
export_file (str): The name of the export file
"""
if name_list is None:
name_list = []
device_template_dict = self.device_templates.get_device_template_dict()
attachments_list = []
# Create a device config of the right type of things
device_list = []
if device_type in (None, 'controllers'):
device_list = self.vmanage_device.get_device_config_list('controllers')
if device_type in (None, 'vedges'):
edge_list = self.vmanage_device.get_device_config_list('vedges')
device_list = device_list + edge_list
for device_config in device_list:
if 'configStatusMessage' in device_config and device_config['configStatusMessage'] != 'In Sync':
continue
if 'template' in device_config:
if device_config['template'] in device_template_dict:
template_id = device_template_dict[device_config['template']]['templateId']
else:
raise Exception(f"Could not find ID for template {device_config['template']}")
if name_list == [] or device_config.get('host-name') in name_list:
variable_dict = {}
template_input = self.device_templates.get_template_input(template_id,
device_id_list=[device_config['uuid']])
data = template_input['data'][0]
for column in template_input['columns']:
variable_dict[column['variable']] = data[column['property']]
entry = {
'host_name': device_config.get('host-name'),
'device_type': device_config['deviceType'],
'uuid': device_config['chasisNumber'],
'system_ip': device_config['deviceIP'],
'site_id': device_config.get('site-id'),
'template': device_config['template'],
'variables': variable_dict
}
attachments_list.append(entry)
attachment_export = {'vmanage_attachments': attachments_list}
if export_file.endswith('.json'):
with open(export_file, 'w') as outfile:
json.dump(attachment_export, outfile, indent=4, sort_keys=False)
elif export_file.endswith(('.yaml', 'yml')):
with open(export_file, 'w') as outfile:
yaml.dump(attachment_export, outfile, indent=4, sort_keys=False)
else:
raise Exception("File format not supported")
return (len(attachments_list))
def import_attachments_from_file(self,
import_file,
update=False,
check_mode=False,
name_list=None,
template_type=None):
"""Import policy from a file. All object Names will be translated to IDs.
Args:
import_file (str): The name of the import file
check_mode (bool): Try the import, but don't make changes (default: False)
update (bool): Update existing templates (default: False)
"""
template_data = {}
# Read in the datafile
if not os.path.exists(import_file):
raise Exception(f"Cannot find file {import_file}")
with open(import_file) as f:
if import_file.endswith('.yaml') or import_file.endswith('.yml'):
template_data = yaml.safe_load(f)
else:
template_data = json.load(f)
if 'vmanage_attachments' in template_data:
imported_attachment_list = template_data['vmanage_attachments']
else:
imported_attachment_list = []
# Process the device templates
result = self.template_data.import_attachment_list(imported_attachment_list,
check_mode=check_mode,
update=update)
return result
