def __init__(self, oid, branch, username=None, administrator=None):
super(UserLDAP, self).__init__(oid, branch)
self._username = storagevalue.StorageValue(self, 'username', username)
self._administrator = storagevalue.StorageBool(self, 'administrator',
administrator)
self._password_hash = storagevalue.StorageValue(
self, 'password-hash', None)
def __init__(self,
oid,
branch,
username=None,
password=None,
administrator=None):
super(UserLocal, self).__init__(oid, branch)
self._username = storagevalue.StorageValue(self, 'username', username)
self._password = storagevalue.StorageValue(self, 'password', password)
self._administrator = storagevalue.StorageBool(self, 'administrator',
administrator)
def __init__(self,
oid,
branch,
attr_name=None,
regexp=None,
versions=None):
super(TemplateRuleRegmatch, self).__init__(oid, branch)
self.attr_name = storagevalue.StorageValue(self, 'attr name',
attr_name)
self.regexp = storagevalue.StorageValue(self, 'regexp', regexp)
self.versions = storagevalue.StorageNumPositive(
self, 'versions', versions)
def __init__(self,
oid,
branch,
attr_name=None,
default_value=None,
versions=None):
super(TemplateRuleInt, self).__init__(oid, branch)
self.attr_name = storagevalue.StorageValue(self, 'attr name',
attr_name)
self.default_value = storagevalue.StorageValue(self, 'default value',
default_value)
self.versions = storagevalue.StorageNumPositive(
self, 'versions', versions)
def __init__(self,
oid,
branch,
server=None,
base_dn=None,
valid_groups=None,
user_domain=None):
super(UserManagerActiveDirectory, self).__init__(oid, branch)
self._server = storagevalue.StorageValue(self, 'server', server)
self._base_dn = storagevalue.StorageValue(self, 'base_dn', base_dn)
self._valid_groups = storagevalue.StorageValue(self, 'valid_groups',
valid_groups)
self._user_domain = storagevalue.StorageValue(self, 'user_domain',
user_domain)
def __init__(self,
oid,
branch,
network_tree=None,
range_start=None,
range_end=None):
super(ConfigNetworkAutoassign, self).__init__(oid, branch)
self.network_tree = storagevalue.StorageNode(self, 'network_tree',
network_tree)
self.range_start = storagevalue.StorageValue(self, 'range_start',
range_start,
self._rangeValidator)
self.range_end = storagevalue.StorageValue(self, 'range_end',
range_end,
self._rangeValidator)
def __init__(self,
oid,
branch,
attr_name=None,
value=None,
variable_expansion=None,
versions=None):
super(TemplateRuleFixed, self).__init__(oid, branch)
self.attr_name = storagevalue.StorageValue(self, 'attr name',
attr_name)
self.value = storagevalue.StorageValue(self, 'value', value)
self.variable_expansion = storagevalue.StorageValue(
self, 'variable expansion', variable_expansion)
self.versions = storagevalue.StorageNumPositive(
self, 'versions', versions)
def __init__(self,
oid,
branch,
connection_type=None,
server=None,
port=None,
base_dn=None,
valid_groups=None):
super(UserManagerLDAP, self).__init__(oid, branch)
self._connection_type = storagevalue.StorageValue(
self, 'connection_type', connection_type)
self._server = storagevalue.StorageValue(self, 'server', server)
self._port = storagevalue.StorageValue(self, 'port', port)
self._base_dn = storagevalue.StorageValue(self, 'base_dn', base_dn)
self._valid_groups = storagevalue.StorageValue(self, 'valid_groups',
valid_groups)
def __init__(self, oid, branch, name = None, atype = None, value = None):
super(EncryptedAttribute, self).__init__(oid, branch)
parent = self.getParentNode()
self._pk = parent.password_key
self._name = name
self._atype = atype
self._value = value
self._lock_data = storagevalue.StorageValue(self, 'enca-lockdata')
def __init__(self, oid, branch, password_key=None, pk_password=None):
super(PublicKey, self).__init__(oid, branch)
self._public_key = storagevalue.StorageText(self, 'public-key', None)
self._private_key = storagevalue.StorageValue(self, 'private-key',
None)
self._password_key = storagevalue.StorageNode(self, 'password-key',
password_key)
self.pk_password = pk_password
def __init__(self,
oid,
branch,
text=None,
key=None,
unicode=True,
pk_password=None):
super(EncryptedText, self).__init__(oid, branch)
if type(text) in [str, unicode] and unicode:
text = text.encode('utf-8')
self._text = storagevalue.StorageValue(self, 'text', text)
self._password_key = storagevalue.StorageValue(self, 'key', key)
self._lock_data = storagevalue.StorageValue(self, 'enctext-lockdata')
self.unicode = unicode
self._pk_password = pk_password
def __init__(self, oid, branch, name = None, atype = None,
value = None, max_versions = None):
super(VersionedAttribute, self).__init__(oid, branch)
self._name = storagevalue.StorageText(self, 'attr-name', name)
self._atype = storagevalue.StorageText(self, 'attr-type', atype,
self._atype_validator)
values = []
if value is not None:
values = [value]
self._values = storagevalue.StorageValue(self, 'attr-values', values,
self._values_validator)
self._max_versions = storagevalue.StorageNum(self, 'attr-max-versions',
max_versions, self._max_versions_validator)
def __init__(self, oid, branch, key=None):
"""Init.
self.password : The PasswordKeys real key (password)
self._encyption_string : The encrypted form of the password used with
encrypt/decrypt methods.
self._verify_clear : Clear text version of the verifier string.
self._verify_crypt : Encrypted version of the verifier string.
Encrypted with self.key, not self.password.
"""
super(PasswordKey, self).__init__(oid, branch)
self.password = key
self._encryption_string = None
self._verify_clear = None
self._verify_crypt = None
self._encryption_string = storagevalue.StorageValue(
self, 'password', None)
self._verify_clear = storagevalue.StorageValue(self, 'verify-clear',
None)
self._verify_crypt = storagevalue.StorageValue(self, 'verify-crypt',
None)
self._subkey_callbacks = []
def __init__(self,
oid,
branch,
password_key=None,
pk_password=None,
public_key=None):
super(PendingSubKey, self).__init__(oid, branch)
self._password_key = storagevalue.StorageNode(self, 'password-key',
password_key)
self._public_key = storagevalue.StorageNode(self, 'public-key',
public_key)
self._pk_password = storagevalue.StorageValue(self, 'pk-password',
pk_password)
def __init__(self,
oid,
branch,
password=None,
key=None,
unicode=True,
pk_password=None):
"""Init.
password is the plaintext password.
key is an optional password key.
unicode determines whether the password should go through
character conversion (if it's a unicode password)
"""
super(Password, self).__init__(oid, branch)
if type(password) in [str, unicode] and unicode:
password = password.encode('utf-8')
self._password = storagevalue.StorageValue(self, 'password', password)
self._password_key = storagevalue.StorageNode(self, 'key', key)
self._lock_data = storagevalue.StorageValue(self, 'password-lockdata')
self.unicode = unicode
self._pk_password = pk_password
def __init__(self, oid, branch):
self.oid = oid
self.branch = branch
# Contains a list of all StorageValue instances used by the node.
# Updated by StorageValue.__init__.
self._storage_actions = []
self._searcher_actions = []
self.object_store = self.branch.tree.ext_data
self.searcher = self.object_store.searcher
self.removed = False
# Creation time.
self.ctime = storagevalue.StorageValue(self, 'ctime', 0)
# Modification time, for internal use.
self.modtime = time.time()
global perm_cache
self.perm_cache = perm_cache
def __init__(self, oid, branch, values = None):
super(CounterLoop, self).__init__(oid, branch)
self._value_pos = storagevalue.StorageValue(self, 'valu_pos', 0)
self._values = storagevalue.StorageValue(self, 'values', values)
def __init__(self, oid, branch):
super(Counter, self).__init__(oid, branch)
self._value = storagevalue.StorageValue(self, 'value')
def __init__(self, oid, branch, username=None, description=None, key=None):
super(TemplateRulePassword, self).__init__(oid, branch)
self.username = storagevalue.StorageValue(self, 'username', username)
self.description = storagevalue.StorageValue(self, 'description',
description)
self.key = storagevalue.StorageNode(self, 'key', key)
def __init__(self, oid, branch, protocol=None):
super(NetworkTree, self).__init__(oid, branch)
self._protocol = storagevalue.StorageValue(self, 'network-protocol',
protocol)
def __init__(self, oid, branch, template = None):
super(DeviceConfigTemplate, self).__init__(oid, branch)
self.template = storagevalue.StorageValue(self, 'template', template, cache_value=False)
def __init__(self, oid, branch, name = None, max_versions = 0):
super(DeviceConfig, self).__init__(oid, branch)
self.name = storagevalue.StorageValue(self, 'name', name,
self._nameValidator)
self.max_versions = storagevalue.StorageNumPositive(self, 'max_versions', max_versions)
def __init__(self, oid, branch, attr_name=None):
super(TemplateRuleDeleteAttribute, self).__init__(oid, branch)
self.attr_name = storagevalue.StorageValue(self, 'attr name',
attr_name)
def __init__(self, oid, branch, include=None, exclude=None):
super(TemplateRuleFlushAssociations, self).__init__(oid, branch)
self.include = storagevalue.StorageValue(self, 'include', include,
self._inclExclValidator)
self.exclude = storagevalue.StorageValue(self, 'exclude', exclude,
self._inclExclValidator)
def __init__(self, oid, branch, name=None, value=None):
super(ConfigValue, self).__init__(oid, branch)
self.name = storagevalue.StorageValue(self, 'name', name,
self._nameValidator)
self.value = storagevalue.StorageValue(self, 'value', value)
