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_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,
password_key=None,
sk_password=None,
pk_password=None):
super(SubKey, self).__init__(oid, branch)
self._password_key = storagevalue.StorageNode(self, 'password-key',
password_key)
self._int_password = None
self.sk_password = sk_password
self.pk_password = pk_password
def __init__(self,
oid,
branch,
num_devices=None,
device_template=None,
sequence_offset=None):
super(TemplateRuleSubdevice, self).__init__(oid, branch)
self.num_devices = storagevalue.StorageNum(self, 'num_devices',
num_devices)
self.device_template = storagevalue.StorageNode(
self, 'device_tmpl', device_template)
self.sequence_offset = storagevalue.StorageNum(self, 'sequence_offset',
sequence_offset)
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,
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, 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)