def create_object(self, channel_id, database_id, dclass, fields={}, callback=None): """ Create an object in the specified database. database_id specifies the control channel of the target database. dclass specifies the class of the object to be created. fields is a dict with any fields that should be stored in the object on creation. callback will be called with callback(do_id) if specified. On failure, do_id is 0. """ # Save the callback: ctx = self.get_context() self._callbacks[ctx] = callback # Pack up/count valid fields. field_packer = DCPacker() field_count = 0 for k, v in fields.items(): field = dclass.get_field_by_name(k) if not field: self.notify.error( 'Creation request for %s object contains an invalid field named %s' % (dclass.get_name(), k)) field_packer.raw_pack_uint16(field.get_number()) field_packer.begin_pack(field) field.pack_args(field_packer, v) field_packer.end_pack() field_count += 1 # Now generate and send the datagram: dg = NetworkDatagram() dg.add_header(database_id, channel_id, types.DBSERVER_CREATE_OBJECT) dg.add_uint32(ctx) dg.add_uint16(dclass.get_number()) dg.add_uint16(field_count) dg.append_data(field_packer.get_string()) self._network.handle_send_connection_datagram(dg)
def handle_update_object_resp(self, di, multi): ctx = di.get_uint32() success = di.get_uint8() if ctx not in self._callbacks: self.notify.warning( 'Received unexpected DBSERVER_OBJECT_SET_FIELD(S)_IF_EQUALS_RESP (ctx %d)' % (ctx)) return try: if success: if self._callbacks[ctx]: self._callbacks[ctx](None) return if not di.get_remaining_size(): # We failed due to other reasons. if self._callbacks[ctx]: return self._callbacks[ctx]({}) if multi: field_count = di.get_uint16() else: field_count = 1 field_packer = DCPacker() field_packer.set_unpack_data(di.get_remaining_bytes()) fields = {} for x in xrange(field_count): fieldId = field_packer.raw_pack_uint16() field = self._network.dc_loader.dc_file.get_field_by_index( fieldId) if not field: self.notify.error( 'Received bad field %d in update failure response message' % (fieldId)) field_packer.begin_unpack(field) fields[field.get_name()] = field.unpack_args(field_packer) field_packer.end_unpack() if self._callbacks[ctx]: self._callbacks[ctx](fields) finally: del self._callbacks[ctx]
def update_object(self, channel_id, database_id, do_id, dclass, new_fields, old_fields=None, callback=None): """ Update field(s) on an object, optionally with the requirement that the fields must match some old value. database_id and do_id represent the database control channel and object ID for the update request. new_fields is to be a dict of fieldname->value, representing the fields to add/change on the database object. old_fields, if specified, is a similarly-formatted dict that contains the expected older values. If the values do not match, the database will refuse to process the update. This is useful for guarding against race conditions. On success, the callback is called as callback(None). On failure, the callback is called as callback(dict), where dict contains the current object values. This is so that the updater can try again, basing its updates off of the new values. """ # Ensure that the keys in new_fields and old_fields are the same if # old_fields is given... if old_fields is not None: if set(new_fields.keys()) != set(old_fields.keys()): self.notify.error( 'new_fields and old_fields must contain the same keys!') return field_packer = DCPacker() field_count = 0 for k, v in new_fields.items(): field = dclass.get_field_by_name(k) if not field: self.notify.error( 'Update for %s(%d) object contains invalid field named %s' % (dclass.get_name(), do_id, k)) field_packer.raw_pack_uint16(field.get_number()) if old_fields is not None: # Pack the old values: field_packer.begin_pack(field) field.pack_args(field_packer, old_fields[k]) field_packer.end() field_packer.begin_pack(field) field.pack_args(field_packer, v) field_packer.end_pack() field_count += 1 # Generate and send the datagram: dg = NetworkDatagram() if old_fields is not None: ctx = self.get_context() self._callbacks[ctx] = callback if field_count == 1: dg.add_header(database_id, channel_id, types.DBSERVER_OBJECT_SET_FIELD_IF_EQUALS) else: dg.add_header(database_id, channel_id, types.DBSERVER_OBJECT_SET_FIELDS_IF_EQUALS) dg.add_uint32(ctx) else: if field_count == 1: dg.add_header(database_id, channel_id, types.DBSERVER_OBJECT_SET_FIELD) else: dg.add_header(database_id, channel_id, types.DBSERVER_OBJECT_SET_FIELDS) dg.add_uint32(do_id) if field_count != 1: dg.add_uint16(field_count) dg.append_data(field_packer.getString()) self._network.handle_send_connection_datagram(dg) if old_fields is None and callback is not None: # Why oh why did they ask for a callback if there's no old_fields? # Oh well, better honor their request: callback(None)
def handle_object_get_all(self, sender, di): context = di.get_uint32() do_id = di.get_uint32() file_object = self._backend.open_file( self._backend.get_filename(do_id)) if not file_object: self.notify.warning( 'Failed to get fields for object: %d context: %d, unknown object!' % (do_id, context)) return dc_name = file_object.get_value('dclass') dc_class = self.dc_loader.dclasses_by_name.get(dc_name) if not dc_class: self.notify.warning( 'Failed to query object: %d context: %d, unknown dclass: %s!' % (do_id, context, dc_name)) return fields = file_object.get_value('fields') if not fields: self.notify.warning( 'Failed to query object: %d context %d, invalid fields!' % (do_id, context)) return datagram = io.NetworkDatagram() datagram.add_header(sender, self.channel, types.DBSERVER_OBJECT_GET_ALL_RESP) datagram.add_uint32(context) datagram.add_uint8(1) field_packer = DCPacker() field_count = 0 for field_name, field_args in fields.items(): field = dc_class.get_field_by_name(field_name) if not field: self.notify.warning( 'Failed to query object %d context: %d, unknown field: %s' % (do_id, context, field_name)) return field_packer.raw_pack_uint16(field.get_number()) field_packer.begin_pack(field) field.pack_args(field_packer, field_args) field_packer.end_pack() field_count += 1 self._backend.close_file(file_object) datagram.add_uint16(dc_class.get_number()) datagram.add_uint16(field_count) datagram.append_data(field_packer.get_string()) self.handle_send_connection_datagram(datagram)