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)
