virtual void handle_datagram(Datagram &in_dg, DatagramIterator &dgi) { channel_t sender = dgi.read_uint64(); unsigned short msg_type = dgi.read_uint16(); switch(msg_type) { case DBSERVER_CREATE_STORED_OBJECT: { unsigned int context = dgi.read_uint32(); // Start response with generic header Datagram resp; resp.add_server_header(sender, m_control_channel, DBSERVER_CREATE_STORED_OBJECT_RESP); resp.add_uint32(context); // Get DistributedClass unsigned short dc_id = dgi.read_uint16(); DCClass *dcc = gDCF->get_class(dc_id); if(!dcc) { m_log->error() << "Invalid DCClass when creating object: #" << dc_id << std::endl; resp.add_uint32(0); send(resp); return; } // Unpack fields to be passed to database DatabaseObject dbo(dc_id); unsigned short field_count = dgi.read_uint16(); m_log->spam() << "Unpacking fields..." << std::endl; try { for(unsigned int i = 0; i < field_count; ++i) { unsigned short field_id = dgi.read_uint16(); DCField *field = dcc->get_field_by_index(field_id); if(field) { if(field->is_db()) { dgi.unpack_field(field, dbo.fields[field]); } else { std::string tmp; dgi.unpack_field(field, tmp); } } } } catch(std::exception &e) { m_log->error() << "Error while unpacking fields, msg may be truncated. e.what(): " << e.what() << std::endl; resp.add_uint32(0); send(resp); return; } // Check for required fields, and populate with defaults m_log->spam() << "Checking all required fields exist..." << std::endl; for(int i = 0; i < dcc->get_num_inherited_fields(); ++i) { DCField *field = dcc->get_inherited_field(i); if(field->is_required() && field->is_db() && !field->as_molecular_field()) { if(dbo.fields.find(field) == dbo.fields.end()) { if(!field->has_default_value()) { m_log->error() << "Field " << field->get_name() << " missing when trying to create " "object of type " << dcc->get_name(); resp.add_uint32(0); send(resp); return; } else { dbo.fields[field] = field->get_default_value(); } } } } // Create object in database m_log->spam() << "Creating stored object..." << std::endl; unsigned int do_id = m_db_engine->create_object(dbo); if(do_id == 0 || do_id < m_min_id || do_id > m_max_id) { m_log->error() << "Ran out of DistributedObject ids while creating new object." << std::endl; resp.add_uint32(0); send(resp); return; } m_log->spam() << "... created with ID: " << do_id << std::endl; resp.add_uint32(do_id); send(resp); } break; case DBSERVER_SELECT_STORED_OBJECT_ALL: { unsigned int context = dgi.read_uint32(); Datagram resp; resp.add_server_header(sender, m_control_channel, DBSERVER_SELECT_STORED_OBJECT_ALL_RESP); resp.add_uint32(context); unsigned int do_id = dgi.read_uint32(); DatabaseObject dbo; if(m_db_engine->get_object(do_id, dbo)) { resp.add_uint8(1); resp.add_uint16(dbo.dc_id); resp.add_uint16(dbo.fields.size()); for(auto it = dbo.fields.begin(); it != dbo.fields.end(); ++it) { resp.add_uint16(it->first->get_number()); resp.add_data(it->second); } } else { resp.add_uint8(0); } send(resp); } break; case DBSERVER_DELETE_STORED_OBJECT: { if(dgi.read_uint32() == DBSERVER_DELETE_STORED_OBJECT_VERIFY_CODE) { unsigned int do_id = dgi.read_uint32(); m_db_engine->delete_object(do_id); m_log->debug() << "Deleted object with ID: " << do_id << std::endl; } else { m_log->warning() << "Wrong delete verify code." << std::endl; } } break; default: m_log->error() << "Recieved unknown MsgType: " << msg_type << std::endl; }; }
void Client::add_interest(Interest &i, uint32_t context) { std::unordered_set<uint32_t> new_zones; for(auto it = i.zones.begin(); it != i.zones.end(); ++it) { if(lookup_interests(i.parent, *it).empty()) { new_zones.insert(*it); } } if(m_interests.find(i.id) != m_interests.end()) { // This is an already-open interest that is actually being altered. // Therefore, we need to delete the objects that the client can see // through this interest only. Interest previous_interest = m_interests[i.id]; std::unordered_set<uint32_t> killed_zones; for(auto it = previous_interest.zones.begin(); it != previous_interest.zones.end(); ++it) { if(lookup_interests(previous_interest.parent, *it).size() > 1) { // An interest other than the altered one can see this parent/zone, // so we don't care about it. continue; } // If we've gotten here: parent,*it is unique, so if the new interest // doesn't cover it, we add it to the killed zones. if(i.parent != previous_interest.parent || i.zones.find(*it) == i.zones.end()) { killed_zones.insert(*it); } } // Now that we know what zones to kill, let's get to it: close_zones(previous_interest.parent, killed_zones); } m_interests[i.id] = i; if(new_zones.empty()) { // We aren't requesting any new zones with this operation, so don't // bother firing off a State Server request. Instead, let the client // know we're already done: handle_interest_done(i.id, context); return; } InterestOperation *iop = new InterestOperation(i.id, context, i.parent, new_zones); uint32_t request_context = m_next_context++; m_pending_interests.insert(std::pair<uint32_t, InterestOperation*>(request_context, iop)); Datagram resp; resp.add_server_header(i.parent, m_channel, STATESERVER_OBJECT_GET_ZONES_OBJECTS); resp.add_uint32(request_context); resp.add_uint32(i.parent); resp.add_uint16(new_zones.size()); for(auto it = new_zones.begin(); it != new_zones.end(); ++it) { resp.add_uint32(*it); subscribe_channel(LOCATION2CHANNEL(i.parent, *it)); } send(resp); }