address_type = AddressType(self.api, address_type_fields)
address_type.sync()
- self.object_ids = [address_type['address_type_id']]
+ self.event_objects = {'AddressType' : [address_type['address_type_id']]}
return address_type['address_type_id']
raise PLCPermissionDenied, "Address must be associated with one of your sites"
address.add_address_type(address_type)
- self.object_ids = [address['address_id']]
+ self.event_objects = {'Address': [address['address_id']]}
return 1
conf_file = ConfFile(self.api, conf_file_fields)
conf_file.sync()
- self.object_ids = [conf_file['conf_file_id']]
+ self.event_objects = {'ConfFile': [conf_file['conf_file_id']]}
return conf_file['conf_file_id']
returns = Parameter(int, '1 if successful')
- object_type = 'Node'
-
-
def call(self, auth, conf_file_id, node_id_or_hostname):
# Get configuration file
conf_files = ConfFiles(self.api, [conf_file_id])
conf_file.add_node(node)
# Log affected objects
- self.object_ids = [conf_file_id, node['node_id']]
+ self.event_objects = {'ConfFile': [conf_file_id],
+ 'Node': [node['node_id']] }
return 1
conf_file.add_nodegroup(nodegroup)
# Log affected objects
- self.object_ids = [conf_file_id, nodegroup['nodegroup_id']]
+ self.event_objects = {'ConfFile': [conf_file_id],
+ 'NodeGroup': [nodegroup['nodegroup_id']] }
return 1
returns = Parameter(int, 'New node_id (> 0) if successful')
- object_type = 'Node'
-
-
def call(self, auth, site_id_or_login_base, node_fields):
node_fields = dict(filter(can_update, node_fields.items()))
node['site_id'] = site['site_id']
node.sync()
- self.object_ids = [site['site_id'], node['node_id']]
+ self.event_objects = {'Site': [site['site_id']],
+ 'Node': [node['node_id']]}
self.message = "Node %s created" % node['node_id']
return node['node_id']
nodegroup.sync()
# Logging variables
- self.object_ids = [nodegroup['nodegroup_id']]
+ self.event_objects = {'NodeGroup': [nodegroup['nodegroup_id']]}
self.message = 'Node group %d created' % nodegroup['nodegroup_id']
return nodegroup['nodegroup_id']
nodegroup.add_node(node)
# Logging variables
- self.object_ids = [nodegroup['nodegroup_id']]
+ self.event_objects = {'NodeGroup': [nodegroup['nodegroup_id']],
+ 'Node': [node['node_id']]}
self.message = 'Node %d added to node group %d' % \
(node['node_id'], nodegroup['nodegroup_id'])
return 1
returns = Parameter(int, '1 if successful')
- object_type = 'Node'
-
def call(self, auth, node_id_or_hostname, pcu_id, port):
# Get node
nodes = Nodes(self.api, [node_id_or_hostname])
pcu.add_node(node, port)
# Logging variables
- self.object_ids = [node['node_id'], pcu['pcu_id']]
+ self.event_objects = {'Node': [node['node_id']],
+ 'PCU': [pcu['pcu_id']]}
self.message = 'Node %d added to pcu %d on port %d' % \
(node['node_id'], pcu['pcu_id'], port)
return 1
pcu.sync()
# Logging variables
- self.object_ids = [site['site_id'], pcu['pcu_id']]
+ self.event_objects = {'Site': [site['site_id']],
+ 'PCU': [pcu['pcu_id']]}
self.message = 'PCU %d added site %s' % \
(pcu['pcu_id'], site['site_id'])
def call(self, auth, peer_fields):
peer = Peer(self.api, peer_fields);
peer.sync()
+ self.event_objects = {'Peer': [peer['peer_id']]}
+
return peer['peer_id']
returns = Parameter(int, 'New person_id (> 0) if successful')
- object_type = 'Person'
-
-
def call(self, auth, person_fields):
person_fields = dict(filter(can_update, person_fields.items()))
person_fields['enabled'] = False
person.sync()
# Logging variables
- self.object_ids = [person['person_id']]
+ self.event_objects = {'Person': [person['person_id']]}
self.message = 'Person %d added' % person['person_id']
return person['person_id']
returns = Parameter(int, 'New key_id (> 0) if successful')
- object_type = 'Person'
-
-
def call(self, auth, person_id_or_email, key_fields):
key_fields = dict(filter(can_update, key_fields.items()))
person.add_key(key, commit = True)
# Logging variables
- self.object_ids = [person['person_id'], key['key_id']]
+ self.event_objects = {'Person': [person['person_id']],
+ 'Key': [key['key_id']]}
self.message = 'Key %d added to person %d' % \
(key['key_id'], person['person_id'])
returns = Parameter(int, '1 if successful')
- object_type = 'Site'
-
def call(self, auth, person_id_or_email, site_id_or_login_base):
# Get account information
persons = Persons(self.api, [person_id_or_email])
site.add_person(person)
# Logging variables
- self.object_ids = [site['site_id']]
+ self.event_objects = {'Site': [site['site_id']],
+ 'Person': [person['person_id']]}
self.message = 'Person %d added to site %d' % \
(person['person_id'], site['site_id'])
return 1
returns = Parameter(int, '1 if successful')
- object_type = 'Slice'
-
def call(self, auth, person_id_or_email, slice_id_or_name):
# Get account information
persons = Persons(self.api, [person_id_or_email])
slice.add_person(person)
# Logging variables
+ self.event_objects = {'Person': [person['person_id']],
+ 'Slice': [slice['slice_id']]}
self.object_ids = [slice['slice_id']]
return 1
role['role_id'] = role_id
role['name'] = name
role.sync(insert = True)
- self.object_ids = [role['role_id']]
+ self.event_objects = {'Role': [role['role_id']]}
return 1
returns = Parameter(int, '1 if successful')
- object_type = 'Person'
-
-
def call(self, auth, role_id_or_name, person_id_or_email):
# Get role
roles = Roles(self.api, [role_id_or_name])
if role['role_id'] not in person['role_ids']:
person.add_role(role)
- self.object_ids = [person['person_id']]
+ self.event_objects = {'Person': [person['person_id']],
+ 'Role': [role['role_id']]}
self.message = "Role %d granted to person %d" % \
(role['role_id'], person['person_id'])
returns = Parameter(int, 'New site_id (> 0) if successful')
- object_type = 'Site'
-
-
def call(self, auth, site_fields):
site_fields = dict(filter(can_update, site_fields.items()))
site = Site(self.api, site_fields)
site.sync()
# Logging variables
- self.object_ids = [site['site_id']]
+ self.event_objects = {'Site': [site['site_id']]}
self.message = 'Site %d created' % site['site_id']
return site['site_id']
returns = Parameter(int, 'New address_id (> 0) if successful')
- object_type = 'Site'
-
-
def call(self, auth, site_id_or_login_base, address_fields):
address_fields = dict(filter(can_update, address_fields.items()))
site.add_address(address, commit = True)
# Logging variables
- self.object_ids = [site['site_id'], address['address_id']]
+ self.event_objects = {'Site': [site['site_id']],
+ 'Address': [address['address_id']]}
self.message = 'Address %d assigned to Site %d' % \
(address['address_id'], site['site_id'])
returns = Parameter(int, 'New slice_id (> 0) if successful')
- object_type = 'Slice'
-
-
def call(self, auth, slice_fields):
slice_fields = dict(filter(can_update, slice_fields.items()))
slice['site_id'] = site['site_id']
slice.sync()
- self.object_ids = [slice['slice_id']]
+ self.event_objects = {'Slice': [slice['slice_id']]}
return slice['slice_id']
returns = Parameter(int, 'New slice_attribute_id (> 0) if successful')
- object_type = 'Slice'
-
-
def call(self, auth, slice_id_or_name, attribute_type_id_or_name, value, node_id_or_hostname = None):
slices = Slices(self.api, [slice_id_or_name])
if not slices:
slice_attribute['node_id'] = node['node_id']
slice_attribute.sync()
- self.object_ids = [slice_attribute['slice_attribute_id']]
+ self.event_objects = {'SliceAttribute': [slice_attribute['slice_attribute_id']]}
return slice_attribute['slice_attribute_id']
attribute_type = SliceAttributeType(self.api, attribute_type_fields)
attribute_type.sync()
- self.object_ids = [attribute_type['attribute_type_id']]
+ self.event_objects = {'AttributeType': [attribute_type['attribute_type_id']]}
return attribute_type['attribute_type_id']
returns = Parameter(int, '1 if successful')
- object_type = 'Node'
-
-
def call(self, auth, slice_id_or_name, node_id_or_hostname_list):
# Get slice information
slices = Slices(self.api, [slice_id_or_name])
slice.sync()
- self.object_ids = [node['node_id'] for node in nodes]
+ self.event_objects = {'Node': [node['node_id'] for node in nodes],
+ 'Slice': [slice['slice_id']]}
return 1
returns = Parameter(int, '1 if successful')
- event_type = 'Update'
- object_type = 'Key'
- object_ids = []
-
def call(self, auth, key_id):
# Get associated key details
keys = Keys(self.api, [key_id])
key.blacklist()
# Logging variables
- self.object_ids = [key['key_id']]
+ self.event_objects = {'Key': [key['key_id']]}
self.message = 'Key %d blacklisted' % key['key_id']
return 1
returns = Parameter(int, '1 if successful')
- object_type = 'Node'
-
def call(self, auth, node_fields):
# Update node state
if node_fields.has_key('boot_state'):