returns = Parameter(int, 'New address_type_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'AddressType'
def call(self, auth, address_type_fields):
address_type_fields = dict(filter(can_update, address_type_fields.items()))
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'Address'
def call(self, auth, address_type_id_or_name, address_id):
address_types = AddressTypes(self.api, [address_type_id_or_name])
returns = Parameter(int, '1 if successful')
- event_type = 'Add'
- object_type = 'BootState'
def call(self, auth, name):
boot_state = BootState(self.api)
returns = Parameter(int, 'New conf_file_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'ConfFile'
def call(self, auth, conf_file_fields):
conf_file_fields = dict(filter(can_update, conf_file_fields.items()))
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'ConfFile'
def call(self, auth, conf_file_id, node_id_or_hostname):
# Get configuration file
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'ConfFile'
def call(self, auth, conf_file_id, nodegroup_id_or_name):
# Get configuration file
returns = Parameter(int, '1 if successful')
- event_type = 'Add'
- object_type = 'KeyType'
def call(self, auth, name):
key_type = KeyType(self.api)
returns = Parameter(int, '1 if successful')
- event_type = 'Add'
- object_type = 'Message'
def call(self, auth, message_fields):
message = Message(self.api, message_fields)
returns = Parameter(int, '1 if successful')
- event_type = 'Add'
- object_type = 'NetworkMethod'
def call(self, auth, name):
network_method = NetworkMethod(self.api)
returns = Parameter(int, '1 if successful')
- event_type = 'Add'
- object_type = 'NetworkType'
def call(self, auth, name):
network_type = NetworkType(self.api)
returns = Parameter(int, 'New node_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'Node'
def call(self, auth, site_id_or_login_base, node_fields):
node_fields = dict(filter(can_update, node_fields.items()))
returns = Parameter(int, 'New nodegroup_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'NodeGroup'
def call(self, auth, nodegroup_fields):
nodegroup_fields = dict(filter(can_update, nodegroup_fields.items()))
returns = Parameter(int, 'New nodenetwork_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'NodeNetwork'
def call(self, auth, node_id_or_hostname, nodenetwork_fields):
nodenetwork_fields = dict(filter(can_update, nodenetwork_fields.items()))
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'NodeGroup'
def call(self, auth, node_id_or_hostname, nodegroup_id_or_name):
# Get node info
]
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'PCU'
def call(self, auth, node_id_or_hostname, pcu_id, port):
# Get node
returns = Parameter(int, 'New pcu_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'PCU'
def call(self, auth, site_id_or_login_base, pcu_fields):
pcu_fields = dict(filter(can_update, pcu_fields.items()))
returns = Parameter(int, 'New person_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'Person'
def call(self, auth, person_fields):
person_fields = dict(filter(can_update, person_fields.items()))
returns = Parameter(int, 'New key_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'Key'
def call(self, auth, person_id_or_email, key_fields):
key_fields = dict(filter(can_update, key_fields.items()))
]
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'Site'
def call(self, auth, person_id_or_email, site_id_or_login_base):
# Get account information
]
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'Slice'
def call(self, auth, person_id_or_email, slice_id_or_name):
# Get account information
returns = Parameter(int, '1 if successful')
- event_type = 'Add'
- object_type = 'Role'
def call(self, auth, role_id, name):
role = Role(self.api)
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'Person'
def call(self, auth, role_id_or_name, person_id_or_email):
# Get all roles
returns = Parameter(int, 'New site_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'Site'
def call(self, auth, site_fields):
site_fields = dict(filter(can_update, site_fields.items()))
returns = Parameter(int, 'New address_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'Address'
def call(self, auth, site_id_or_login_base, address_fields):
address_fields = dict(filter(can_update, address_fields.items()))
returns = Parameter(int, 'New slice_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'Slice'
def call(self, auth, slice_fields):
slice_fields = dict(filter(can_update, slice_fields.items()))
returns = Parameter(int, 'New slice_attribute_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'SliceAttribute'
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])
returns = Parameter(int, 'New attribute_id (> 0) if successful')
- event_type = 'Add'
- object_type = 'SliceAttributeType'
def call(self, auth, attribute_type_fields):
attribute_type_fields = dict(filter(can_update, attribute_type_fields.items()))
returns = Parameter(int, '1 if successful')
- event_type = 'Add'
- object_type = 'SliceInstantiation'
def call(self, auth, name):
slice_instantiation = SliceInstantiation(self.api)
returns = Parameter(int, '1 if successful')
- event_type = 'AddTo'
- object_type = 'Node'
def call(self, auth, slice_id_or_name, node_id_or_hostname_list):
# Get slice information
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Address'
def call(self, auth, address_id):
# Get associated address details
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'AddressType'
def call(self, auth, address_type_id_or_name):
address_types = AddressTypes(self.api, [address_type_id_or_name])
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'Address'
def call(self, auth, address_type_id_or_name, address_id):
address_types = AddressTypes(self.api, [address_type_id_or_name])
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'BootState'
def call(self, auth, name):
boot_states = BootStates(self.api, [name])
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'ConfFile'
def call(self, auth, conf_file_id):
conf_files = ConfFiles(self.api, [conf_file_id])
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'ConfFile'
def call(self, auth, conf_file_id, node_id_or_hostname):
# Get configuration file
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'ConfFile'
def call(self, auth, conf_file_id, nodegroup_id_or_name):
# Get configuration file
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Key'
def call(self, auth, key_id):
# Get associated key details
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'KeyType'
def call(self, auth, name):
key_types = KeyTypes(self.api, [name])
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Message'
def call(self, auth, message_id):
# Get message information
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'NetworkMethod'
def call(self, auth, name):
network_methods = NetworkMethods(self.api, [name])
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'NetworkType'
def call(self, auth, name):
network_types = NetworkTypes(self.api, [name])
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Node'
def call(self, auth, node_id_or_hostname):
# Get account information
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'NodeGroup'
def call(self, auth, node_id_or_hostname, nodegroup_id_or_name):
# Get node info
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'PCU'
def call(self, auth, node_id_or_hostname, pcu_id):
# Get node
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'NodeGroup'
def call(self, auth, node_group_id_or_name):
# Get account information
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'NodeNetwork'
def call(self, auth, nodenetwork_id):
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'PCU'
def call(self, auth, pcu_id):
# Get associated PCU details
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Person'
def call(self, auth, person_id_or_email):
# Get account information
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'Site'
def call(self, auth, person_id_or_email, site_id_or_login_base):
# Get account information
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'Slice'
def call(self, auth, person_id_or_email, slice_id_or_name):
# Get account information
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Role'
def call(self, auth, role_id_or_name):
roles = Roles(self.api, [role_id_or_name])
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'Person'
def call(self, auth, role_id_or_name, person_id_or_email):
# Get all roles
accepts = [SessionAuth()]
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Session'
def call(self, auth):
assert auth.has_key('session')
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Site'
def call(self, auth, site_id_or_login_base):
# Get account information
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'Slice'
def call(self, auth, slice_id_or_name):
slices = Slices(self.api, [slice_id_or_name])
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'SliceAttribute'
def call(self, auth, slice_attribute_id):
slice_attributes = SliceAttributes(self.api, [slice_attribute_id])
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'SliceAttributeType'
def call(self, auth, attribute_type_id_or_name):
attribute_types = SliceAttributeTypes(self.api, [attribute_type_id_or_name])
returns = Parameter(int, '1 if successful')
- event_type = 'DeleteFrom'
- object_type = 'Node'
def call(self, auth, slice_id_or_name, node_id_or_hostname_list):
# Get slice information
returns = Parameter(int, '1 if successful')
- event_type = 'Delete'
- object_type = 'SliceInstantiation'
def call(self, auth, instantiation):
slice_instantiations = SliceInstantiations(self.api, [instantiation])
returns = [AddressType.fields]
- event_type = 'Get'
- object_type = 'AddressType'
def call(self, auth, address_type_filter = None, return_fields = None):
return AddressTypes(self.api, address_type_filter, return_fields)
returns = [Address.fields]
- event_type = 'Get'
- object_type = 'Address'
def call(self, auth, address_filter = None, return_fields = None):
return Addresses(self.api, address_filter, return_fields)
returns = [BootState.fields['boot_state']]
- event_type = 'Get'
- object_type = 'BootState'
def call(self, auth):
return [boot_state['boot_state'] for boot_state in BootStates(self.api)]
returns = [ConfFile.fields]
- event_type = 'Get'
- object_type = 'ConfFile'
def call(self, auth, conf_file_filter = None, return_fields = None):
return ConfFiles(self.api, conf_file_filter, return_fields)
]
returns = [Event.fields]
- event_type = 'Get'
- object_type = 'Event'
def call(self, auth, event_filter = None, return_fields = None):
return Events(self.api, event_filter, return_fields)
returns = [KeyType.fields['key_type']]
- event_type = 'Get'
- object_type = 'KeyType'
def call(self, auth):
return [key_type['key_type'] for key_type in KeyTypes(self.api)]
returns = [Key.fields]
- event_type = 'Get'
- object_type = 'Key'
def call(self, auth, key_filter = None, return_fields = None):
keys = Keys(self.api, key_filter, return_fields)
returns = [Message.fields]
- event_type = 'Get'
- object_type = 'Message'
def call(self, auth, message_ids = None):
return Messages(self.api, message_ids)
returns = [NetworkMethod.fields['method']]
- event_type = 'Get'
- object_type = 'NetworkMethod'
def call(self, auth):
return [network_method['method'] for network_method in NetworkMethods(self.api)]
returns = [NetworkType.fields['type']]
- event_type = 'Get'
- object_type = 'NetworkType'
def call(self, auth):
return [network_type['type'] for network_type in NetworkTypes(self.api)]
]
returns = [NodeGroup.fields]
- event_type = 'Get'
- object_type = 'NodeGroup'
def call(self, auth, nodegroup_filter = None, return_fields = None):
return NodeGroups(self.api, nodegroup_filter, return_fields)
returns = [NodeNetwork.fields]
- event_type = 'Get'
- object_type = 'NodeNetwork'
def call(self, auth, nodenetwork_filter = None, return_fields = None):
return NodeNetworks(self.api, nodenetwork_filter, return_fields)
returns = [Node.fields]
- event_type = 'Get'
- object_type = 'Node'
def call(self, auth, node_filter = None, return_fields = None):
# Get node information
]
returns = [PCU.fields]
- event_type = 'Get'
- object_type = 'PCU'
def call(self, auth, pcu_filter = None, return_fields = None):
# If we are not admin, make sure to only return our own PCUs
]
# for RefreshPeer
returns = Parameter (dict,"Sites, Keys, Nodes, Persons, Slices")
- event_type = 'Get'
- object_type = 'Peer'
def call (self, auth, peer_id):
# xxx a peer cannot yet compute it's peer_id under another plc
]
returns = [Peer.fields]
- event_type = 'Get'
- object_type = 'Peer'
def call (self, auth, peer_filter = None, return_fields = None):
return Peers(self.api, peer_filter, return_fields)
return_fields = dict(filter(can_return, Person.fields.items()))
returns = [return_fields]
- event_type = 'Get'
- object_type = 'Person'
def call(self, auth, person_filter = None, return_fields = None):
returns = [Role.fields]
- event_type = 'Get'
- object_type = 'Role'
def call(self, auth):
return Roles(self.api)
accepts = [Auth()]
returns = Session.fields['session_id']
- event_type = 'Get'
- object_type = 'Session'
def call(self, auth):
# Authenticated with a session key, just return it
returns = [Site.fields]
- event_type = 'Get'
- object_type = 'Site'
def call(self, auth, site_filter = None, return_fields = None):
return Sites(self.api, site_filter, return_fields)
returns = [SliceAttributeType.fields]
- event_type = 'Get'
- object_type = 'SliceAttributeType'
def call(self, auth, attribute_type_filter = None, return_fields = None):
return SliceAttributeTypes(self.api, attribute_type_filter, return_fields)
returns = [SliceAttribute.fields]
- event_type = 'Get'
- object_type = 'SliceAttribute'
def call(self, auth, slice_attribute_filter = None, return_fields = None):
# If we are not admin, make sure to only return our own slice
returns = [SliceInstantiation.fields['instantiation']]
- event_type = 'Get'
- object_type = 'SliceInstantiation'
def call(self, auth):
return [slice_instantiation['instantiation'] for slice_instantiation in SliceInstantiations(self.api)]
returns = [Slice.fields]
- event_type = 'Get'
- object_type = 'Slice'
def call(self, auth, slice_filter = None, return_fields = None):
# If we are not admin, make sure to return only viewable
}]
}]
- event_type = 'Get'
- object_type = 'Sliver'
def call(self, auth, node_filter = None):
timestamp = int(time.time())
git://git.onelab.eu / plcapi.git / commitdiff