#
# 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)
#
# ACPAnnc.py
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# Acp : Announceable variant
#
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,
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: mgmtObj:DeviceCapability
#
from .MgmtObj import *
from Constants import Constants as C
from Validator import constructPolicy
import Utils
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa',
'daci', 'mgd', 'obis', 'obps', 'dc', 'mgs', 'cmlk', 'can', 'att', 'cas',
'ena', 'dis', 'cus'
])
class DVC(MgmtObj):
def __init__(self,
jsn: dict = None,
pi: str = None,
create: bool = False) -> None:
super().__init__(jsn,
pi,
C.tsDVC,
C.mgdDVC,
create=create,
attributePolicies=attributePolicies)
# # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # CSR : Announceable variant # 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)
#
# 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)
#
# 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)
from Validator import constructPolicy, addPolicy
from Logging import Logging
import Utils, CSE
from .Resource import *
from .AnnounceableResource import AnnounceableResource
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',
'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,
#
# FCI.py
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: FlexContainerInstance
#
from Constants import Constants as C
from .Resource import *
from Validator import constructPolicy
import Utils
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy(
['ty', 'ri', 'rn', 'pi', 'ct', 'et', 'lbl', 'acpi', 'cs'])
class FCI(Resource):
def __init__(self,
jsn: dict = None,
pi: str = None,
fcntType: str = None,
create: bool = False) -> None:
super().__init__(fcntType,
jsn,
pi,
C.tFCI,
create=create,
inheritACP=True,
readOnly=True,
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'rn',
'ty',
'ri',
'pi',
'et',
'lbl',
'ct',
'lt',
'cr',
'hld',
'acpi',
'daci',
'enc',
'exc',
'nu',
'gpi',
'nfu',
'bn',
'rl',
'psn',
'pn',
'nsp',
'ln',
'nct',
'nec',
'su',
'acrs' # primitiveProfileID missing in TS-0004
])
import Utils
from .Resource import *
from Logging import Logging
from .AnnounceableResource import AnnounceableResource
import CSE
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty',
'ri',
'rn',
'pi',
'acpi',
'ct',
'lt',
'et',
'lbl',
'at',
'aa',
'daci',
'loc',
'st',
'hld',
])
aePolicies = constructPolicy([
'apn', 'api', 'aei', 'poa', 'nl', 'rr', 'csz', 'esi', 'mei', 'srv', 'regs',
'trps', 'scp', 'tren', 'ape', 'or'
])
attributePolicies = addPolicy(attributePolicies, aePolicies)
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: mgmtObj:DeviceInfo
#
from .MgmtObj import *
from Constants import Constants as C
from Validator import constructPolicy
import Utils
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa', 'daci',
'mgd', 'obis', 'obps', 'dc', 'mgs', 'cmlk',
'dlb', 'man', 'mfdl', 'mfd', 'mod', 'smod', 'dty', 'dvnm', 'fwv', 'swv',
'hwv', 'osv', 'cnty', 'loc', 'syst', 'spur', 'purl', 'ptl'
])
defaultDeviceType = 'unknown'
defaultModel = "unknown"
defaultManufacturer = "unknown"
defaultDeviceLabel = "unknown serial id"
class DVI(MgmtObj):
def __init__(self, jsn: dict = None, pi: str = None, create: bool = False) -> None:
super().__init__(jsn, pi, C.tsDVI, C.mgdDVI, create=create, attributePolicies=attributePolicies)
if self.json is not None:
self.setAttribute('dty', defaultDeviceType, overwrite=False)
#
# 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)
#
# ResourceType: Container
#
from typing import Tuple, List
from Logging import Logging
from Configuration import Configuration
from Constants import Constants as C
from Validator import constructPolicy
import Utils, CSE
from .Resource import *
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'st', 'lbl', 'at', 'aa', 'daci', 'loc',
'cr',
'mni', 'mbs', 'mia', 'cni', 'cbs', 'li', 'or', 'disr'
])
class CNT(Resource):
def __init__(self, jsn: dict = None, pi: str = None, create: bool = False) -> None:
super().__init__(C.tsCNT, jsn, pi, C.tCNT, create=create, attributePolicies=attributePolicies)
if self.json is not None:
self.setAttribute('mni', Configuration.get('cse.cnt.mni'), overwrite=False)
self.setAttribute('mbs', Configuration.get('cse.cnt.mbs'), overwrite=False)
self.setAttribute('cni', 0, overwrite=False)
self.setAttribute('cbs', 0, overwrite=False)
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: mgmtObj:areaNwkDeviceInfo
#
from .MgmtObj import *
from Constants import Constants as C
from Validator import constructPolicy
import Utils
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa',
'daci', 'mgd', 'obis', 'obps', 'dc', 'mgs', 'cmlk', 'dvd', 'dvt', 'awi',
'sli', 'sld', 'ss', 'lnh'
])
defaultAreaNwkType = ''
class ANDI(MgmtObj):
def __init__(self,
jsn: dict = None,
pi: str = None,
create: bool = False) -> None:
super().__init__(jsn,
pi,
C.tsANDI,
C.mgdANDI,
# # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # CNT : Announceable variant # 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
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: AccessControlPolicy
#
from typing import Tuple, List
from Constants import Constants as C
from Validator import constructPolicy
from .Resource import *
import Utils
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'rn', 'ty', 'ri', 'pi', 'et', 'lbl', 'ct', 'lt', 'at', 'aa',
'pv', 'pvs', 'adri', 'apri', 'airi'
])
class ACP(Resource):
def __init__(self, jsn: dict = None, pi: str = None, rn: str = None, create: bool = False, createdInternally: str = None) -> None:
super().__init__(C.tsACP, jsn, pi, C.tACP, create=create, inheritACP=True, rn=rn, attributePolicies=attributePolicies)
if self.json is not None:
self.setAttribute('pv/acr', [], overwrite=False)
self.setAttribute('pvs/acr', [], overwrite=False)
if createdInternally is not None:
self.setAttribute(self._createdInternally, createdInternally)
# Enable check for allowed sub-resources
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: RemoteCSE
#
from Constants import Constants as C
from Types import ResourceTypes as T, Result, JSON
from Configuration import Configuration
from Validator import constructPolicy, addPolicy
from .Resource import *
from .AnnounceableResource import AnnounceableResource
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa', 'cr',
'daci', 'loc', 'hld'
])
csrPolicies = constructPolicy([
'cst', 'poa', 'cb', 'csi', 'mei', 'tri', 'rr', 'nl', 'csz', 'esi', 'trn',
'dcse', 'mtcc', 'egid', 'tren', 'ape', 'srv'
])
attributePolicies = addPolicy(attributePolicies, csrPolicies)
# TODO ^^^ Add Attribute EnableTimeCompensation, also in CSRAnnc
class CSR(AnnounceableResource):
def __init__(self,
dct: JSON = None,
pi: str = None,
rn: str = None,
# DVI.py
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: mgmtObj:DeviceInfo
#
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
dviPolicies = constructPolicy([
'dlb', 'man', 'mfdl', 'mfd', 'mod', 'smod', 'dty', 'dvnm', 'fwv', 'swv',
'hwv', 'osv', 'cnty', 'loc', 'syst', 'spur', 'purl', 'ptl'
])
attributePolicies = addPolicy(mgmtObjAttributePolicies, dviPolicies)
defaultDeviceType = 'unknown'
defaultModel = "unknown"
defaultManufacturer = "unknown"
defaultDeviceLabel = "unknown serial id"
class DVI(MgmtObj):
def __init__(self,
dct: JSON = None,
pi: str = None,
create: bool = False) -> None:
self.resourceAttributePolicies = dviPolicies # only the resource type's own policies
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: mgmtObj:Software
#
from .MgmtObj import *
from Constants import Constants as C
from Validator import constructPolicy
import Utils
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa',
'daci', 'mgd', 'obis', 'obps', 'dc', 'mgs', 'cmlk', 'vr', 'swn', 'url',
'ins', 'acts', 'in', 'un', 'act', 'dea'
])
statusUninitialized = 0
statusSuccessful = 1
statusFailure = 2
statusInProcess = 3
defaultSoftwareName = 'unknown'
defaultVersion = '0.0'
defaultURL = 'unknown'
defaultStatus = {'acn': '', 'sus': statusUninitialized}
class SWR(MgmtObj):
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ResourceType: CSEBase
#
from Constants import Constants as C
from Types import ResourceTypes as T, Result, JSON
from Configuration import Configuration
from Validator import constructPolicy
from .Resource import *
import CSE
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'rn', 'ty', 'ri', 'pi', 'ct', 'lt', 'lbl', 'loc', 'hld', 'acpi', 'poa',
'nl', 'daci', 'esi', 'srv', 'cst', 'csi', 'csz'
])
class CSEBase(Resource):
def __init__(self, dct: JSON = None, create: bool = False) -> None:
super().__init__(T.CSEBase,
dct,
'',
create=create,
attributePolicies=attributePolicies)
if self.dict is not None:
self.setAttribute('ri', 'cseid', overwrite=False)
self.setAttribute('rn', 'cse', overwrite=False)
self.setAttribute('csi', 'cse', overwrite=False)
from Constants import Constants as C
from Types import ResourceTypes as T, Result, ResponseCode as RC, JSON
from Validator import constructPolicy, addPolicy
from .Resource import *
from .AnnounceableResource import AnnounceableResource
import Utils
# Attribute policies for this resource are constructed during startup of the CSE
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:
from Logging import Logging
from .Resource import *
from .AnnounceableResource import AnnounceableResource
import resources.Factory as Factory
import functools
# Attribute policies for this resource are constructed during startup of the CSE
attributePolicies = constructPolicy([
'ty',
'ri',
'rn',
'pi',
'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,
# MgmtObjAnnc.py
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# MgmtObj : Announceable variant
#
from copy import deepcopy
from .AnnouncedResource import AnnouncedResource
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,
#
# ANIAnnc.py
#
# (c) 2020 by Andreas Kraft
# License: BSD 3-Clause License. See the LICENSE file for further details.
#
# ANI : 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
aniAPolicies = constructPolicy(['ant', 'ldv'])
attributePolicies = addPolicy(mgmtObjAAttributePolicies, aniAPolicies)
# TODO resourceMappingRules, announceSyncType, owner
class ANIAnnc(MgmtObjAnnc):
def __init__(self,
dct: JSON = None,
pi: str = None,
create: bool = False) -> None:
super().__init__(dct,
pi,
mgd=T.ANI,
create=create,
attributePolicies=attributePolicies)
# DVC.py
#
# (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)
# from typing import Dict, Any from Constants import Constants as C from Types import ResourceTypes as T, ResponseCode as RC, Result, RequestArguments, RequestHeaders, Operation, RequestStatus, CSERequest, JSON 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:
import Utils, CSE
from Validator import constructPolicy, addPolicy
from .Resource import *
from .AnnounceableResource import AnnounceableResource
# TODO Support cmdhPolicy
# TODO Support storage
attributePolicies = constructPolicy([
'ty',
'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,
# # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # FCI : Announceable variant # 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:
#
# ANDIAnnc.py
#
# (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)
# # (c) 2020 by Andreas Kraft # License: BSD 3-Clause License. See the LICENSE file for further details. # # ResourceType: mgmtObj:EventLog # from .MgmtObj import * from Constants import Constants as C from Validator import constructPolicy import Utils # Attribute policies for this resource are constructed during startup of the CSE attributePolicies = constructPolicy([ 'ty', 'ri', 'rn', 'pi', 'acpi', 'ct', 'lt', 'et', 'lbl', 'at', 'aa', 'daci', 'mgd', 'obis', 'obps', 'dc', 'mgs', 'cmlk', 'lgt', 'lgd', 'lgst', 'lga', 'lgo' ]) lgtSystem = 1 lgtSecurity = 2 lgtEvent = 3 lgtTrace = 4 lgTPanic = 5 lgstStarted = 1 lgstStopped = 2 lgstUnknown = 3 lgstNotPresent = 4 lgstError = 5
