Fr/feature templates

pyproject.toml

@@ -15,6 +15,8 @@ aiohttp = "^3.8.1"
 ciscoconfparse = "^1.6.40"
 tenacity = "^8.1.0"
 parameterized = "^0.8.1"
+cattrs = "^22.2.0"
+pydantic = "^1.10.4"
 Jinja2 = "^3.1.2"
 flake8-quotes = "^3.3.1"
 clint = "^0.5.1"

vmngclient/api/templates.py → vmngclient/api/template_api.py

@@ -2,13 +2,15 @@
 import logging
 from difflib import Differ
 from enum import Enum
-from typing import List
+from typing import List, Optional
 
 from ciscoconfparse import CiscoConfParse  # type: ignore
 from requests.exceptions import HTTPError
 
 from vmngclient.api.task_status_api import wait_for_completed
-from vmngclient.dataclasses import Device, Template
+from vmngclient.api.templates.feature_template import FeatureTemplate
+from vmngclient.dataclasses import Device, FeatureTemplateInformation, Template
+from vmngclient.exceptions import InvalidOperationError
 from vmngclient.session import vManageSession
 from vmngclient.utils.creation_tools import create_dataclass
 from vmngclient.utils.device_model import DeviceModel
@@ -22,14 +24,14 @@ class TemplateType(Enum):
     FEATURE = "template"
 
 
-class NotFoundError(Exception):
+class TemplateNotFoundError(Exception):
     """Used when a template item is not found."""
 
     def __init__(self, template):
         self.message = f"No such template: '{template}'"
 
 
-class NameAlreadyExistError(Exception):
+class TemplateAlreadyExistsError(Exception):
     """Used when a template item exists."""
 
     def __init__(self, name):
@@ -50,7 +52,7 @@ def __init__(self, name):
         self.message = f"Template: {name} - wrong template type."
 
 
-class TemplateAPI:
+class TemplatesAPI:
     def __init__(self, session: vManageSession) -> None:
         self.session = session
 
@@ -72,15 +74,15 @@ def get(self, name: str) -> Template:
             name (str): Name of template.
 
         Raises:
-            NotFoundError: If template does not exist.
+            TemplateNotFoundError: If template does not exist.
 
         Returns:
             Template: Selected template.
         """
         for template in self.templates:
             if name == template.name:
                 return template
-        raise NotFoundError(name)
+        raise TemplateNotFoundError(name)
 
     def get_id(self, name: str) -> str:
         """
@@ -106,7 +108,7 @@ def attach(self, name: str, device: Device) -> bool:
         try:
             template_id = self.get_id(name)
             self.template_validation(template_id, device=device)
-        except NotFoundError:
+        except TemplateNotFoundError:
             logger.error(f"Error, Template with name {name} not found on {device}.")
             return False
         except HTTPError as error:
@@ -199,21 +201,59 @@ def create(
             config (CiscoConfParse): The config to device.
 
         Raises:
-            NameAlreadyExistError: If such template name already exists.
+            TemplateAlreadyExistsError: If such template name already exists.
 
         Returns:
             bool: True if create template is successful, otherwise - False.
         """
         try:
             self.get(name)
             logger.error(f"Error, Template with name: {name} exists.")
-            raise NameAlreadyExistError(name)
-        except NotFoundError:
+            raise TemplateAlreadyExistsError(name)
+        except TemplateNotFoundError:
             cli_template = CLITemplate(self.session, device_model, name, description)
             cli_template.config = config
             logger.info(f"Template with name: {name} - created.")
             return cli_template.send_to_device()
 
+    def create_feature_template(self, template: FeatureTemplate) -> str:
+        try:
+            self.get_single_feature_template(name=template.name)
+        except TemplateNotFoundError:
+            payload = template.generate_payload(self.session)
+            response = self.session.post("/dataservice/template/feature", json=json.loads(payload))
+            template_id = response.json()["templateId"]
+            logger.info(f"Template {template.name} was created successfully ({template_id}).")
+            return template_id
+        raise TemplateAlreadyExistsError(template.name)
+
+    def get_feature_templates(self, name: Optional[str] = None) -> List[FeatureTemplateInformation]:
+        """Get feature template list.
+
+        Note: In a multitenant vManage system, this API is only available in the Provider view.
+        """
+        payload = {"summary": "true"}
+        response = self.session.get("/dataservice/template/feature", params=payload)
+        parsed_response = response.json()["data"]
+        fr_templates = [
+            create_dataclass(FeatureTemplateInformation, feature_template) for feature_template in parsed_response
+        ]
+
+        if name is None:
+            return fr_templates
+        return list(filter(lambda template: template.name == name, fr_templates))
+
+    def get_single_feature_template(self, name: str) -> FeatureTemplateInformation:
+        fr_templates = self.get_feature_templates(name=name)
+
+        if not fr_templates:
+            raise TemplateNotFoundError(name)
+
+        if len(fr_templates) > 1:
+            raise InvalidOperationError("The input sequence contains more than one element.")
+
+        return fr_templates[0]
+
     def template_validation(self, id: str, device: Device) -> str:
         """Checking the template of the configuration on the machine.
 

vmngclient/api/templates/__init__.py

@@ -0,0 +1,41 @@
+"""Contains a list of feature templates.
+
+These feature template models are used to create and modify the templates
+on the vManage server.
+
+In addition, they are used to convert CLI config into separate feature
+templates in vManage.
+"""
+
+# Basic FeatureTemplate class
+from vmngclient.api.templates.feature_template import FeatureTemplate
+
+# AAA Templates
+from vmngclient.api.templates.payloads.aaa.aaa_model import AAAModel
+
+# Cisco VPN Templates
+from vmngclient.api.templates.payloads.cisco_vpn.cisco_vpn_model import (
+    DNS,
+    CiscoVPNModel,
+    GatewayType,
+    IPv4Route,
+    IPv6Route,
+    Mapping,
+    NextHop,
+)
+
+# CEdge Templates
+from vmngclient.api.templates.payloads.tenant.tenant_model import TenantModel
+
+__all__ = [
+    "FeatureTemplate",
+    "TenantModel",
+    "AAAModel",
+    "CiscoVPNModel",
+    "DNS",
+    "Mapping",
+    "IPv4Route",
+    "IPv6Route",
+    "GatewayType",
+    "NextHop",
+]

vmngclient/api/templates/feature_template.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from jinja2 import DebugUndefined, Environment, FileSystemLoader, meta  # type: ignore
+from pydantic import BaseModel  # type: ignore
+
+from vmngclient.session import vManageSession
+
+
+class FeatureTemplate(BaseModel, ABC):
+    name: str
+    description: str
+
+    def generate_payload(self, session: vManageSession) -> str:
+        env = Environment(
+            loader=FileSystemLoader(self.payload_path.parent),
+            trim_blocks=True,
+            lstrip_blocks=True,
+            undefined=DebugUndefined,
+        )
+        template = env.get_template(self.payload_path.name)
+        output = template.render(self.dict())
+
+        ast = env.parse(output)
+        if meta.find_undeclared_variables(ast):
+            print(meta.find_undeclared_variables(ast))
+            raise Exception
+        return output
+
+    def generate_cli(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def payload_path(self) -> Path:
+        raise NotImplementedError()