attributePolicies = constructPolicy([ 'rn', 'ty', 'ri', 'pi', 'et', 'ct', 'lt', 'st', 'lbl', 'at', 'aa', 'cr', ]) cinPolicies = constructPolicy(['cnf', 'cs', 'conr', 'con', 'or', 'conr']) attributePolicies = addPolicy(attributePolicies, cinPolicies) class CIN(AnnounceableResource): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: super().__init__(T.CIN, dct, pi, create=create, inheritACP=True, readOnly=True, attributePolicies=attributePolicies)
from .AnnouncedResource import AnnouncedResource from .Resource import * from Types import ResourceTypes as T, JSON from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE attributePolicies = constructPolicy([ 'et', 'acpi', 'lbl','daci', 'loc', 'lnk' ]) csrAPolicies = constructPolicy([ 'cst', 'poa', 'cb', 'csi', 'rr', 'nl', 'csz', 'esi', 'dcse', 'mtcc', 'egid', 'tren', 'ape', 'srv' ]) attributePolicies = addPolicy(attributePolicies, csrAPolicies) # TODO announceSyncType class CSRAnnc(AnnouncedResource): def __init__(self, dct:JSON=None, pi:str=None, create:bool=False) -> None: super().__init__(T.CSRAnnc, dct, pi=pi, create=create, attributePolicies=attributePolicies) # Enable check for allowed sub-resources def canHaveChild(self, resource:Resource) -> bool: return super()._canHaveChild(resource, [ T.CNT, T.CNTAnnc,
# EVLAnnc.py # # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # EVL : Announceable variant # from .MgmtObjAnnc import * from Types import ResourceTypes as T, JSON import Utils from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE evlAPolicies = constructPolicy(['lgt', 'lgd', 'lgst', 'lga', 'lgo']) attributePolicies = addPolicy(mgmtObjAAttributePolicies, evlAPolicies) # TODO resourceMappingRules, announceSyncType, owner class EVLAnnc(MgmtObjAnnc): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = evlAPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.EVL, create=create, attributePolicies=attributePolicies)
'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa', 'daci', 'cr', 'hld', ]) grpPolicies = constructPolicy([ 'mt', 'spty', 'cnm', 'mnm', 'mid', 'macp', 'mtv', 'csy', 'gn', 'ssi', 'nar' ]) attributePolicies = addPolicy(attributePolicies, grpPolicies) class GRP(AnnounceableResource): def __init__(self, dct: JSON = None, pi: str = None, fcntType: str = None, create: bool = False) -> None: super().__init__(T.GRP, dct, pi, create=create, attributePolicies=attributePolicies) self.resourceAttributePolicies = grpPolicies # only the resource type's own policies
'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa', 'daci', 'hld', ]) nodPolicies = constructPolicy( ['ni', 'hcl', 'hael', 'hsl', 'mgca', 'rms', 'nid', 'nty']) attributePolicies = addPolicy(attributePolicies, nodPolicies) class NOD(AnnounceableResource): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: super().__init__(T.NOD, dct, pi, create=create, attributePolicies=attributePolicies) self.resourceAttributePolicies = nodPolicies # only the resource type's own policies
# ANI.py # # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # ResourceType: mgmtObj:areaNwkInfo # from .MgmtObj import * from Types import ResourceTypes as T, JSON from Validator import constructPolicy, addPolicy import Utils # Attribute policies for this resource are constructed during startup of the CSE aniPolicies = constructPolicy(['ant', 'ldv']) attributePolicies = addPolicy(mgmtObjAttributePolicies, aniPolicies) defaultAreaNwkType = '' class ANI(MgmtObj): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = aniPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.ANI, create=create, attributePolicies=attributePolicies)
'acpi', 'ct', 'lt', 'et', 'st', 'lbl', 'at', 'aa', 'cr', 'hld', 'daci', 'loc', ]) fcntPolicies = constructPolicy( ['cnd', 'or', 'cs', 'nl', 'mni', 'mia', 'mbs', 'cni', 'dgt']) attributePolicies = addPolicy(attributePolicies, fcntPolicies) class FCNT(AnnounceableResource): def __init__(self, dct: JSON = None, pi: str = None, fcntType: str = None, create: bool = False) -> None: super().__init__(T.FCNT, dct, pi, tpe=fcntType, create=create, attributePolicies=attributePolicies)
# (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # ResourceType: mgmtObj:DeviceCapability # from .MgmtObj import * from Types import ResourceTypes as T, Result, ResponseCode as RC, JSON from Validator import constructPolicy, addPolicy import Utils # Attribute policies for this resource are constructed during startup of the CSE dvcPolicies = constructPolicy([ 'can', 'att', 'cas', 'ena', 'dis', 'cus' ]) attributePolicies = addPolicy(mgmtObjAttributePolicies, dvcPolicies) class DVC(MgmtObj): def __init__(self, dct:JSON=None, pi:str=None, create:bool=False) -> None: self.resourceAttributePolicies = dvcPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.DVC, create=create, attributePolicies=attributePolicies) if self.dict is not None: self.setAttribute('can', 'unknown', overwrite=False) self.setAttribute('att', False, overwrite=False) self.setAttribute('cas', { "acn" : "unknown", "sus" : 0 }, overwrite=False) self.setAttribute('cus', False, overwrite=False) self.setAttribute('ena', True, overwrite=True) # always True self.setAttribute('dis', True, overwrite=True) # always True
# BATAnnc.py # # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # BAT : Announceable variant # from .MgmtObjAnnc import * from Types import ResourceTypes as T, JSON import Utils from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE batAPolicies = constructPolicy(['btl', 'bts']) attributePolicies = addPolicy(mgmtObjAAttributePolicies, batAPolicies) # TODO resourceMappingRules, announceSyncType, owner class BATAnnc(MgmtObjAnnc): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = batAPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.BAT, create=create, attributePolicies=attributePolicies)
# NYCFCnnc.py # # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # NYCFC : Announceable variant # from .MgmtObjAnnc import * from Types import ResourceTypes as T, JSON import Utils from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE nycfcAPolicies = constructPolicy(['suids', 'mcff', 'mcfc']) attributePolicies = addPolicy(mgmtObjAAttributePolicies, nycfcAPolicies) # TODO resourceMappingRules, announceSyncType, owner class NYCFCAnnc(MgmtObjAnnc): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = nycfcAPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.NYCFC, create=create, attributePolicies=attributePolicies)
attributePolicies = constructPolicy([ 'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'daci', ]) pchPolicies = constructPolicy([ # No own attributes ]) attributePolicies = addPolicy(attributePolicies, pchPolicies) class PCH(Resource): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: super().__init__(T.PCH, dct, pi, create=create, attributePolicies=attributePolicies) self.resourceAttributePolicies = pchPolicies # only the resource type's own policies # Enable check for allowed sub-resources
# RBOAnnc.py # # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # RBO : Announceable variant # from .MgmtObjAnnc import * from Types import ResourceTypes as T, JSON import Utils from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE rboAPolicies = constructPolicy(['rbo', 'far']) attributePolicies = addPolicy(mgmtObjAAttributePolicies, rboAPolicies) # TODO resourceMappingRules, announceSyncType, owner class RBOAnnc(MgmtObjAnnc): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = rboAPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.RBO, create=create, attributePolicies=attributePolicies)
# # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # ResourceType: mgmtObj:Software # from .MgmtObj import * from Types import ResourceTypes as T, JSON from Validator import constructPolicy, addPolicy import Utils # Attribute policies for this resource are constructed during startup of the CSE swrPolicies = constructPolicy( ['vr', 'swn', 'url', 'ins', 'acts', 'in', 'un', 'act', 'dea']) attributePolicies = addPolicy(mgmtObjAttributePolicies, swrPolicies) statusUninitialized = 0 statusSuccessful = 1 statusFailure = 2 statusInProcess = 3 defaultSoftwareName = 'unknown' defaultVersion = '0.0' defaultURL = 'unknown' defaultStatus = {'acn': '', 'sus': statusUninitialized} class SWR(MgmtObj): def __init__(self, dct: JSON = None,
from .Resource import * from Types import ResourceTypes as T, JSON, AttributePolicies from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE attributePolicies = constructPolicy( ['et', 'acpi', 'lbl', 'daci', 'loc', 'lnk']) mgmtObjAPolicies = constructPolicy([ 'mgd', 'obis', 'obps', 'dc', 'mgs', 'cmlk', ]) mgmtObjAAttributePolicies = addPolicy(attributePolicies, mgmtObjAPolicies) # TODO resourceMappingRules, announceSyncType class MgmtObjAnnc(AnnouncedResource): def __init__(self, dct: JSON, pi: str, mgd: T, create: bool = False, attributePolicies: AttributePolicies = None) -> None: super().__init__(T.MGMTOBJAnnc, dct, pi, tpe=f'{mgd.tpe()}A', create=create,
from Validator import constructPolicy, addPolicy import Utils from .Resource import * from .AnnounceableResource import AnnounceableResource from Configuration import Configuration import resources.Factory as Factory # Attribute policies for this resource are constructed during startup of the CSE attributePolicies = constructPolicy([ 'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'daci', 'hld', ]) reqPolicies = constructPolicy([ 'op', 'tg', 'org', 'rid', 'mi', 'pc', 'rs', 'ors' ]) attributePolicies = addPolicy(attributePolicies, reqPolicies) class REQ(Resource): def __init__(self, dct:JSON=None, pi:str=None, create:bool=False) -> None: super().__init__(T.REQ, dct, pi, create=create, attributePolicies=attributePolicies) # Enable check for allowed sub-resources def canHaveChild(self, resource:Resource) -> bool: return super()._canHaveChild(resource, [ T.SUB ]) @staticmethod def createRequestResource(request:CSERequest) -> Result:
# MEMAnnc.py # # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # MEM : Announceable variant # from .MgmtObjAnnc import * from Types import ResourceTypes as T, JSON import Utils from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE memAPolicies = constructPolicy(['mma', 'mmt']) attributePolicies = addPolicy(mgmtObjAAttributePolicies, memAPolicies) # TODO resourceMappingRules, announceSyncType, owner class MEMAnnc(MgmtObjAnnc): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = memAPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.MEM, create=create, attributePolicies=attributePolicies)
# from .AnnouncedResource import AnnouncedResource from .Resource import * from Types import ResourceTypes as T, JSON from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE attributePolicies = constructPolicy([ 'et', 'acpi', 'lbl','daci', 'loc', 'lnk' ]) fcinAPolicies = constructPolicy([ ]) attributePolicies = addPolicy(attributePolicies, fcinAPolicies) # TODO announceSyncType class FCIAnnc(AnnouncedResource): def __init__(self, dct:JSON=None, pi:str=None, create:bool=False) -> None: super().__init__(T.FCIAnnc, dct, pi=pi, create=create, attributePolicies=attributePolicies) # Enable check for allowed sub-resources def canHaveChild(self, resource:Resource) -> bool: return super()._canHaveChild(resource, [])
from .AnnouncedResource import AnnouncedResource from .Resource import * from Types import ResourceTypes as T, Permission, JSON from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE attributePolicies = constructPolicy( ['et', 'acpi', 'lbl', 'daci', 'loc', 'lnk']) acpAPolicies = constructPolicy([ 'pv', 'pvs', 'adri', 'apri', 'airi', ]) attributePolicies = addPolicy(attributePolicies, acpAPolicies) # TODO announceSyncType class ACPAnnc(AnnouncedResource): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: super().__init__(T.ACPAnnc, dct, pi=pi, create=create, attributePolicies=attributePolicies) # Enable check for allowed sub-resources
from .AnnouncedResource import AnnouncedResource from .Resource import * from Types import ResourceTypes as T, JSON from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE attributePolicies = constructPolicy([ 'et', 'acpi', 'lbl','daci', 'loc', 'lnk' ]) cntAPolicies = constructPolicy([ 'mni', 'mbs', 'mia', 'li', 'or', 'disr' ]) attributePolicies = addPolicy(attributePolicies, cntAPolicies) # TODO announceSyncType class CNTAnnc(AnnouncedResource): def __init__(self, dct:JSON=None, pi:str=None, create:bool=False) -> None: super().__init__(T.CNTAnnc, dct, pi=pi, create=create, attributePolicies=attributePolicies) # Enable check for allowed sub-resources def canHaveChild(self, resource:Resource) -> bool: return super()._canHaveChild(resource, [ T.CNT, T.CNTAnnc, T.CIN,
# # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # ANDI : Announceable variant # from .MgmtObjAnnc import * from Types import ResourceTypes as T, JSON import Utils from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE andiAPolicies = constructPolicy( ['dvd', 'dvt', 'awi', 'sli', 'sld', 'ss', 'lnh']) attributePolicies = addPolicy(mgmtObjAAttributePolicies, andiAPolicies) # TODO resourceMappingRules, announceSyncType, owner class ANDIAnnc(MgmtObjAnnc): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = andiAPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.ANDI, create=create, attributePolicies=attributePolicies)
# FWRAnnc.py # # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # FWR : Announceable variant # from .MgmtObjAnnc import * from Types import ResourceTypes as T, JSON import Utils from Validator import constructPolicy, addPolicy # Attribute policies for this resource are constructed during startup of the CSE fwrAPolicies = constructPolicy(['vr', 'fwn', 'url', 'uds', 'ud']) attributePolicies = addPolicy(mgmtObjAAttributePolicies, fwrAPolicies) # TODO resourceMappingRules, announceSyncType, owner class FWRAnnc(MgmtObjAnnc): def __init__(self, dct: JSON = None, pi: str = None, create: bool = False) -> None: self.resourceAttributePolicies = fwrAPolicies # only the resource type's own policies super().__init__(dct, pi, mgd=T.FWR, create=create, attributePolicies=attributePolicies)